Attachment 875028 Details for Bug 1224402

preprocessed source

nv-procfs.i (text/plain), 2.95 MB, created by Michal Suchanek on 2024-05-22 14:26:33 UTC

(hide)

Description:

Filename:

MIME Type:

Creator: Michal Suchanek

Created: 2024-05-22 14:26:33 UTC

Size: 2.95 MB

patch

obsolete

># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c"
># 1 "/usr/src/linux-5.14.21-150500.53-obj/x86_64/default//"
># 1 "<built-in>"
># 1 "<command-line>"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler-version.h" 1
># 1 "<command-line>" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kconfig.h" 1
>
>
>
>
># 1 "./include/generated/autoconf.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/kconfig.h" 2
># 1 "<command-line>" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h" 1
># 73 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_attributes.h" 1
># 74 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h" 2
># 93 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler-gcc.h" 1
># 94 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h" 2
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h"
>struct ftrace_branch_data {
> const char *func;
> const char *file;
> unsigned line;
> union {
>  struct {
>   unsigned long correct;
>   unsigned long incorrect;
>  };
>  struct {
>   unsigned long miss;
>   unsigned long hit;
>  };
>  unsigned long miss_hit[2];
> };
>};
>
>struct ftrace_likely_data {
> struct ftrace_branch_data data;
> unsigned long constant;
>};
># 1 "<command-line>" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c"
># 12 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-misc.h" 1
># 14 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-misc.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h" 1
># 63 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/cpuopsys.h" 1
># 64 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h" 2
># 75 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef float NvF32;
>typedef double NvF64;
>
>
>
>typedef unsigned char NvV8;
>typedef unsigned char NvU8;
>typedef signed char NvS8;
>
>
>
>
>typedef unsigned short int NvV16;
>typedef unsigned short int NvU16;
>typedef signed short int NvS16;
># 110 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef NvU8* NVREGSTR;
>
>
>
>
>
>typedef unsigned int NvV32;
>typedef unsigned int NvU32;
>typedef signed int NvS32;
># 154 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef unsigned long long NvU64;
>typedef long long NvS64;
># 193 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef NvU32 NvHandle;
>
>
>
>typedef NvU8 NvBool;
>
>
>
>
>typedef NvU8 NvTristate;
># 226 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef void* NvP64;
>typedef NvU64 NvUPtr;
>typedef NvS64 NvSPtr;
>typedef NvU64 NvLength;
># 362 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef struct
>{
>
>
>
>    NvU32 lo;
>
>
>
>    NvU32 hi;
>} NvU64_ALIGN32;
>
>
>typedef NvP64 NvP64_VALUE_T;
># 388 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef NvV8 V008;
>typedef NvV16 V016;
>typedef NvV32 V032;
>typedef NvU8 U008;
>typedef NvU16 U016;
>typedef NvU32 U032;
>typedef NvS8 S008;
>typedef NvS16 S016;
>typedef NvS32 S032;
># 405 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef unsigned long ULONG;
>
>typedef unsigned char *PUCHAR;
># 627 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef NvS16 NvSFXP16;
>typedef NvS32 NvSFXP32;
>typedef NvU16 NvUFXP16;
>typedef NvU32 NvUFXP32;
>typedef NvU64 NvUFXP64;
># 644 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef NvSFXP16 NvSFXP11_5;
>typedef NvSFXP16 NvSFXP4_12;
>typedef NvSFXP16 NvSFXP8_8;
>typedef NvSFXP32 NvSFXP8_24;
>typedef NvSFXP32 NvSFXP10_22;
>typedef NvSFXP32 NvSFXP16_16;
>typedef NvSFXP32 NvSFXP18_14;
>typedef NvSFXP32 NvSFXP20_12;
>typedef NvSFXP32 NvSFXP24_8;
>typedef NvSFXP32 NvSFXP27_5;
>typedef NvSFXP32 NvSFXP28_4;
>typedef NvSFXP32 NvSFXP29_3;
>typedef NvSFXP32 NvSFXP31_1;
>
>typedef NvUFXP16 NvUFXP0_16;
>typedef NvUFXP16 NvUFXP4_12;
>typedef NvUFXP16 NvUFXP8_8;
>typedef NvUFXP32 NvUFXP4_28;
>typedef NvUFXP32 NvUFXP8_24;
>typedef NvUFXP32 NvUFXP9_23;
>typedef NvUFXP32 NvUFXP10_22;
>typedef NvUFXP32 NvUFXP16_16;
>typedef NvUFXP32 NvUFXP20_12;
>typedef NvUFXP32 NvUFXP24_8;
>typedef NvUFXP32 NvUFXP25_7;
>typedef NvUFXP32 NvUFXP28_4;
>
>typedef NvUFXP64 NvUFXP40_24;
>typedef NvUFXP64 NvUFXP48_16;
>typedef NvUFXP64 NvUFXP52_12;
># 862 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
>typedef NvSFXP24_8 NvTemp;
># 884 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/xapi-sdk.h" 1
># 885 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h" 2
># 15 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-misc.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvstatus.h" 1
># 38 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvstatus.h"
>typedef NvU32 NV_STATUS;
>
>
>
>enum
>{
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvstatuscodes.h" 1
># 32 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvstatuscodes.h"
>NV_OK = 0x00000000,
>NV_ERR_GENERIC = 0x0000FFFF,
>
>NV_ERR_BROKEN_FB = 0x00000001,
>NV_ERR_BUFFER_TOO_SMALL = 0x00000002,
>NV_ERR_BUSY_RETRY = 0x00000003,
>NV_ERR_CALLBACK_NOT_SCHEDULED = 0x00000004,
>NV_ERR_CARD_NOT_PRESENT = 0x00000005,
>NV_ERR_CYCLE_DETECTED = 0x00000006,
>NV_ERR_DMA_IN_USE = 0x00000007,
>NV_ERR_DMA_MEM_NOT_LOCKED = 0x00000008,
>NV_ERR_DMA_MEM_NOT_UNLOCKED = 0x00000009,
>NV_ERR_DUAL_LINK_INUSE = 0x0000000A,
>NV_ERR_ECC_ERROR = 0x0000000B,
>NV_ERR_FIFO_BAD_ACCESS = 0x0000000C,
>NV_ERR_FREQ_NOT_SUPPORTED = 0x0000000D,
>NV_ERR_GPU_DMA_NOT_INITIALIZED = 0x0000000E,
>NV_ERR_GPU_IS_LOST = 0x0000000F,
>NV_ERR_GPU_IN_FULLCHIP_RESET = 0x00000010,
>NV_ERR_GPU_NOT_FULL_POWER = 0x00000011,
>NV_ERR_GPU_UUID_NOT_FOUND = 0x00000012,
>NV_ERR_HOT_SWITCH = 0x00000013,
>NV_ERR_I2C_ERROR = 0x00000014,
>NV_ERR_I2C_SPEED_TOO_HIGH = 0x00000015,
>NV_ERR_ILLEGAL_ACTION = 0x00000016,
>NV_ERR_IN_USE = 0x00000017,
>NV_ERR_INFLATE_COMPRESSED_DATA_FAILED = 0x00000018,
>NV_ERR_INSERT_DUPLICATE_NAME = 0x00000019,
>NV_ERR_INSUFFICIENT_RESOURCES = 0x0000001A,
>NV_ERR_INSUFFICIENT_PERMISSIONS = 0x0000001B,
>NV_ERR_INSUFFICIENT_POWER = 0x0000001C,
>NV_ERR_INVALID_ACCESS_TYPE = 0x0000001D,
>NV_ERR_INVALID_ADDRESS = 0x0000001E,
>NV_ERR_INVALID_ARGUMENT = 0x0000001F,
>NV_ERR_INVALID_BASE = 0x00000020,
>NV_ERR_INVALID_CHANNEL = 0x00000021,
>NV_ERR_INVALID_CLASS = 0x00000022,
>NV_ERR_INVALID_CLIENT = 0x00000023,
>NV_ERR_INVALID_COMMAND = 0x00000024,
>NV_ERR_INVALID_DATA = 0x00000025,
>NV_ERR_INVALID_DEVICE = 0x00000026,
>NV_ERR_INVALID_DMA_SPECIFIER = 0x00000027,
>NV_ERR_INVALID_EVENT = 0x00000028,
>NV_ERR_INVALID_FLAGS = 0x00000029,
>NV_ERR_INVALID_FUNCTION = 0x0000002A,
>NV_ERR_INVALID_HEAP = 0x0000002B,
>NV_ERR_INVALID_INDEX = 0x0000002C,
>NV_ERR_INVALID_IRQ_LEVEL = 0x0000002D,
>NV_ERR_INVALID_LIMIT = 0x0000002E,
>NV_ERR_INVALID_LOCK_STATE = 0x0000002F,
>NV_ERR_INVALID_METHOD = 0x00000030,
>NV_ERR_INVALID_OBJECT = 0x00000031,
>NV_ERR_INVALID_OBJECT_BUFFER = 0x00000032,
>NV_ERR_INVALID_OBJECT_HANDLE = 0x00000033,
>NV_ERR_INVALID_OBJECT_NEW = 0x00000034,
>NV_ERR_INVALID_OBJECT_OLD = 0x00000035,
>NV_ERR_INVALID_OBJECT_PARENT = 0x00000036,
>NV_ERR_INVALID_OFFSET = 0x00000037,
>NV_ERR_INVALID_OPERATION = 0x00000038,
>NV_ERR_INVALID_OWNER = 0x00000039,
>NV_ERR_INVALID_PARAM_STRUCT = 0x0000003A,
>NV_ERR_INVALID_PARAMETER = 0x0000003B,
>NV_ERR_INVALID_PATH = 0x0000003C,
>NV_ERR_INVALID_POINTER = 0x0000003D,
>NV_ERR_INVALID_REGISTRY_KEY = 0x0000003E,
>NV_ERR_INVALID_REQUEST = 0x0000003F,
>NV_ERR_INVALID_STATE = 0x00000040,
>NV_ERR_INVALID_STRING_LENGTH = 0x00000041,
>NV_ERR_INVALID_READ = 0x00000042,
>NV_ERR_INVALID_WRITE = 0x00000043,
>NV_ERR_INVALID_XLATE = 0x00000044,
>NV_ERR_IRQ_NOT_FIRING = 0x00000045,
>NV_ERR_IRQ_EDGE_TRIGGERED = 0x00000046,
>NV_ERR_MEMORY_TRAINING_FAILED = 0x00000047,
>NV_ERR_MISMATCHED_SLAVE = 0x00000048,
>NV_ERR_MISMATCHED_TARGET = 0x00000049,
>NV_ERR_MISSING_TABLE_ENTRY = 0x0000004A,
>NV_ERR_MODULE_LOAD_FAILED = 0x0000004B,
>NV_ERR_MORE_DATA_AVAILABLE = 0x0000004C,
>NV_ERR_MORE_PROCESSING_REQUIRED = 0x0000004D,
>NV_ERR_MULTIPLE_MEMORY_TYPES = 0x0000004E,
>NV_ERR_NO_FREE_FIFOS = 0x0000004F,
>NV_ERR_NO_INTR_PENDING = 0x00000050,
>NV_ERR_NO_MEMORY = 0x00000051,
>NV_ERR_NO_SUCH_DOMAIN = 0x00000052,
>NV_ERR_NO_VALID_PATH = 0x00000053,
>NV_ERR_NOT_COMPATIBLE = 0x00000054,
>NV_ERR_NOT_READY = 0x00000055,
>NV_ERR_NOT_SUPPORTED = 0x00000056,
>NV_ERR_OBJECT_NOT_FOUND = 0x00000057,
>NV_ERR_OBJECT_TYPE_MISMATCH = 0x00000058,
>NV_ERR_OPERATING_SYSTEM = 0x00000059,
>NV_ERR_OTHER_DEVICE_FOUND = 0x0000005A,
>NV_ERR_OUT_OF_RANGE = 0x0000005B,
>NV_ERR_OVERLAPPING_UVM_COMMIT = 0x0000005C,
>NV_ERR_PAGE_TABLE_NOT_AVAIL = 0x0000005D,
>NV_ERR_PID_NOT_FOUND = 0x0000005E,
>NV_ERR_PROTECTION_FAULT = 0x0000005F,
>NV_ERR_RC_ERROR = 0x00000060,
>NV_ERR_REJECTED_VBIOS = 0x00000061,
>NV_ERR_RESET_REQUIRED = 0x00000062,
>NV_ERR_STATE_IN_USE = 0x00000063,
>NV_ERR_SIGNAL_PENDING = 0x00000064,
>NV_ERR_TIMEOUT = 0x00000065,
>NV_ERR_TIMEOUT_RETRY = 0x00000066,
>NV_ERR_TOO_MANY_PRIMARIES = 0x00000067,
>NV_ERR_UVM_ADDRESS_IN_USE = 0x00000068,
>NV_ERR_MAX_SESSION_LIMIT_REACHED = 0x00000069,
>NV_ERR_LIB_RM_VERSION_MISMATCH = 0x0000006A,
>NV_ERR_PRIV_SEC_VIOLATION = 0x0000006B,
>NV_ERR_GPU_IN_DEBUG_MODE = 0x0000006C,
>NV_ERR_FEATURE_NOT_ENABLED = 0x0000006D,
>
>
>NV_WARN_HOT_SWITCH = 0x00010001,
>NV_WARN_INCORRECT_PERFMON_DATA = 0x00010002,
>NV_WARN_MISMATCHED_SLAVE = 0x00010003,
>NV_WARN_MISMATCHED_TARGET = 0x00010004,
>NV_WARN_MORE_PROCESSING_REQUIRED = 0x00010005,
>NV_WARN_NOTHING_TO_DO = 0x00010006,
>NV_WARN_NULL_OBJECT = 0x00010007,
>NV_WARN_OUT_OF_RANGE = 0x00010008,
># 45 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvstatus.h" 2
>};
># 122 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvstatus.h"
>const char *nvstatusToString(NV_STATUS nvStatusIn);
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-misc.h" 2
># 34 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-misc.h"
>typedef void *PHWINFO;
># 13 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
>
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h" 1
># 27 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv_stdarg.h" 1
># 29 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv_stdarg.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 1
>
>
>
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/headers.h" 1
># 5 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/functions.h" 1
># 22 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/functions.h"
>typedef unsigned long long nv_acpi_integer_t;
># 6 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/generic.h" 1
># 7 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/macros.h" 1
># 8 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/symbols.h" 1
># 9 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/types.h" 1
># 10 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/conftest.h" 2
># 30 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv_stdarg.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stdarg.h" 1
>
>
>
>
>typedef __builtin_va_list va_list;
># 32 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv_stdarg.h" 2
># 28 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kernel-interface-api.h" 1
># 29 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvipmi.h" 1
># 47 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvipmi.h"
>typedef struct nvipmi_req
>{
>    NvU8 netfn;
>    NvU8 lun;
>    NvU8 cmd;
>    NvU8 target_cmd;
>    NvU16 data_len;
>    NvU8 *data;
>} nvipmi_req_t;
>
>typedef struct nvipmi_resp
>{
>    NvU8 ccode;
>    NvS16 data_len;
>    NvU8 data[1024];
>} nvipmi_resp_t;
>
>typedef struct nvipmi_req_resp
>{
>    nvipmi_req_t req;
>    nvipmi_resp_t resp;
>} nvipmi_req_resp_t;
># 30 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h" 2
># 39 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h"
>typedef struct
>{
>    NvU32 os_major_version;
>    NvU32 os_minor_version;
>    NvU32 os_build_number;
>    char * os_build_version_str;
>    char * os_build_date_plus_str;
>}os_version_info;
># 56 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h"
>NvU32 os_get_page_size (void);
>NvU64 os_get_page_mask (void);
>NvU8 os_get_page_shift (void);
>NvU64 os_get_num_phys_pages (void);
>NV_STATUS os_alloc_mem (void **, NvU64);
>void os_free_mem (void *);
>NV_STATUS os_get_current_time (NvU32 *, NvU32 *);
>void os_get_current_tick (NvU64 *);
>NV_STATUS os_delay (NvU32);
>NV_STATUS os_delay_us (NvU32);
>NvU64 os_get_cpu_frequency (void);
>NvU32 os_get_current_process (void);
>void os_get_current_process_name (char *, NvU32);
>NvU32 os_get_current_pasid (void);
>NV_STATUS os_get_current_thread (NvU64 *);
>char* os_string_copy (char *, const char *);
>NvU32 os_string_length (const char *);
>NvU32 os_strtoul (const char *, char **, NvU32);
>NvS32 os_string_compare (const char *, const char *);
>NvS32 os_snprintf (char *, NvU32, const char *, ...);
>void os_log_error (const char *, va_list);
>NvU8* os_mem_copy (NvU8 *, const NvU8 *, NvU32);
>NV_STATUS os_memcpy_from_user (void *, const void *, NvU32);
>NV_STATUS os_memcpy_to_user (void *, const void *, NvU32);
>void* os_mem_set (void *, NvU8, NvU32);
>NvS32 os_mem_cmp (const NvU8 *, const NvU8 *, NvU32);
>void* os_pci_init_handle (NvU32, NvU8, NvU8, NvU8, NvU16 *, NvU16 *);
>NV_STATUS os_pci_read_byte (void *, NvU32, NvU8 *);
>NV_STATUS os_pci_read_word (void *, NvU32, NvU16 *);
>NV_STATUS os_pci_read_dword (void *, NvU32, NvU32 *);
>NV_STATUS os_pci_write_byte (void *, NvU32, NvU8);
>NV_STATUS os_pci_write_word (void *, NvU32, NvU16);
>NV_STATUS os_pci_write_dword (void *, NvU32, NvU32);
>NvBool os_pci_remove_supported (void);
>void os_pci_remove (void *);
>void* os_map_kernel_space (NvU64, NvU64, NvU32, NvU32);
>void os_unmap_kernel_space (void *, NvU64);
>void os_unmap_kernel_numa (void *, NvU64);
>void* os_map_user_space (NvU64, NvU64, NvU32, NvU32, void **);
>void os_unmap_user_space (void *, NvU64, void *);
>NV_STATUS os_flush_cpu_cache (void);
>NV_STATUS os_flush_cpu_cache_all (void);
>NV_STATUS os_flush_user_cache (NvU64, NvU64, NvU64, NvU64, NvU32);
>void os_flush_cpu_write_combine_buffer(void);
>NvU8 os_io_read_byte (NvU32);
>NvU16 os_io_read_word (NvU32);
>NvU32 os_io_read_dword (NvU32);
>void os_io_write_byte (NvU32, NvU8);
>void os_io_write_word (NvU32, NvU16);
>void os_io_write_dword (NvU32, NvU32);
>NvS32 os_is_administrator (PHWINFO);
>void os_dbg_init (void);
>void os_dbg_breakpoint (void);
>void os_dbg_set_level (NvU32);
>NvU32 os_get_cpu_count (void);
>NvU32 os_get_cpu_number (void);
>NV_STATUS os_disable_console_access (void);
>NV_STATUS os_enable_console_access (void);
>NV_STATUS os_registry_init (void);
>NV_STATUS os_schedule (void);
>NV_STATUS os_alloc_spinlock (void **);
>void os_free_spinlock (void *);
>NvU64 os_acquire_spinlock (void *);
>void os_release_spinlock (void *, NvU64);
>NV_STATUS os_get_address_space_info (NvU64 *, NvU64 *, NvU64 *, NvU64 *);
>NV_STATUS os_queue_work_item (void *);
>NV_STATUS os_flush_work_queue (void);
>void os_register_compatible_ioctl (NvU32, NvU32);
>void os_unregister_compatible_ioctl (NvU32, NvU32);
>NV_STATUS os_alloc_mutex (void **);
>void os_free_mutex (void *);
>NV_STATUS os_acquire_mutex (void *);
>NV_STATUS os_cond_acquire_mutex (void *);
>void os_release_mutex (void *);
>void* os_alloc_semaphore (NvU32);
>void os_free_semaphore (void *);
>NV_STATUS os_acquire_semaphore (void *);
>NV_STATUS os_release_semaphore (void *);
>NvS32 os_semaphore_may_sleep (void);
>NV_STATUS os_get_version_info (os_version_info*);
>NvS32 os_is_isr (void);
>NvS32 os_pat_supported (void);
>void os_dump_stack (void);
>NvS32 os_is_efi_enabled (void);
>NvS32 os_iommu_is_snooping_enabled(void);
>NvBool os_is_xen_dom0 (void);
>NvBool os_is_vgx_hyper (void);
>NV_STATUS os_inject_vgx_msi (NvU16, NvU64, NvU32);
>NvBool os_is_grid_supported (void);
>void os_get_screen_info (NvU64 *, NvU16 *, NvU16 *, NvU16 *, NvU16 *);
>void os_bug_check (NvU32, const char *);
>NV_STATUS os_lock_user_pages (void *, NvU64, void **);
>NV_STATUS os_lookup_user_io_memory (void *, NvU64, NvU64 **);
>NV_STATUS os_unlock_user_pages (NvU64, void *);
>NV_STATUS os_match_mmap_offset (void *, NvU64, NvU64 *);
>NV_STATUS os_get_euid (NvU32 *);
>NV_STATUS os_get_smbios_header (NvU64 *pSmbsAddr);
>NV_STATUS os_get_acpi_rsdp_from_uefi (NvU32 *);
>void os_add_record_for_crashLog (void *, NvU32);
>void os_delete_record_for_crashLog (void *);
>NV_STATUS os_call_vgpu_vfio (void *, NvU32);
>NV_STATUS os_numa_memblock_size(NvU64 *);
>NV_STATUS os_numa_online_memory(NvS32, NvU64, NvU64, NvU64, NvU64, NvBool);
>void os_numa_offline_memory(NvS32);
>NV_STATUS os_alloc_pages_node (NvS32, NvU32, NvU32, NvU64 *);
>NV_STATUS os_get_page (NvU64 address);
>NV_STATUS os_put_page (NvU64 address);
>void os_free_pages_phys (NvU64, NvU32);
>NV_STATUS os_ipmi_connect (NvU32 devIndex, NvU8 myAddr, void **ppOsPriv);
>void os_ipmi_disconnect (void *pOsPriv);
>NV_STATUS os_ipmi_send_receive_cmd (void *pOsPriv, nvipmi_req_resp_t *pReq);
># 194 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h"
>void out_string(const char *str);
>int nv_printf(NvU32 debuglevel, const char *printf_format, ...);
># 15 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 1
># 15 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-misc.h" 1
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h" 1
># 15 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvlimits.h" 1
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvtypes.h" 1
># 17 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvCpuUuid.h" 1
># 28 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nvCpuUuid.h"
>typedef struct nv_uuid
>{
>    NvU8 uuid[16];
>
>} NvUuid;
>
>typedef NvUuid NvSystemUuid;
>
>typedef NvUuid NvProcessorUuid;
>
>
>
>
>static const NvProcessorUuid NV_PROCESSOR_UUID_CPU_DEFAULT =
>{
>    {
>
>       0xa6, 0x5e, 0x0f, 0x4e, 0xd7, 0xd4, 0x7b, 0xa2,
>       0x50, 0x47, 0x41, 0x2c, 0x14, 0x2a, 0x77, 0x73
>    }
>};
># 18 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h" 2
># 36 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct {
>    NvU32 domain;
>    NvU8 bus;
>    NvU8 slot;
>    NvU8 function;
>    NvU16 vendor_id;
>    NvU16 device_id;
>    NvBool valid;
>} nv_pci_info_t;
># 86 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct nv_ioctl_xfer
>{
>    NvU32 cmd;
>    NvU32 size;
>    NvP64 ptr __attribute__ ((aligned (8)));
>} nv_ioctl_xfer_t;
>
>typedef struct nv_ioctl_card_info
>{
>    NvU16 flags;
>    nv_pci_info_t pci_info;
>    NvU32 gpu_id;
>    NvU16 interrupt_line;
>    NvU64 reg_address __attribute__ ((aligned (8)));
>    NvU64 reg_size __attribute__ ((aligned (8)));
>    NvU64 fb_address __attribute__ ((aligned (8)));
>    NvU64 fb_size __attribute__ ((aligned (8)));
>    NvU32 minor_number;
>    NvU8 dev_name[10];
>} nv_ioctl_card_info_t;
># 120 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct nv_ioctl_env_info
>{
>    NvU32 pat_supported;
>} nv_ioctl_env_info_t;
># 133 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct nv_ioctl_rm_api_old_version
>{
>    NvU32 magic;
>    NvU32 major;
>    NvU32 minor;
>    NvU32 patch;
>} nv_ioctl_rm_api_old_version_t;
>
>
>
>
>
>
>
>typedef enum {
>    NV_CPU_TYPE_UNKNOWN = 0,
>    NV_CPU_TYPE_ARM_A9
>} nv_cpu_type_t;
>
>
>typedef struct nv_ioctl_alloc_os_event
>{
>    NvHandle hClient;
>    NvHandle hDevice;
>    NvHandle hOsEvent;
>    NvU32 fd;
>    NvU32 Status;
>} nv_ioctl_alloc_os_event_t;
>
>
>typedef struct nv_ioctl_free_os_event
>{
>    NvHandle hClient;
>    NvHandle hDevice;
>    NvU32 fd;
>    NvU32 Status;
>} nv_ioctl_free_os_event_t;
>
>
>
>
>
>
>typedef struct nv_ioctl_status_code
>{
>    NvU32 domain;
>    NvU8 bus;
>    NvU8 slot;
>    NvU32 status;
>} nv_ioctl_status_code_t;
>
>
>
>
>typedef struct nv_ioctl_rm_api_version
>{
>    NvU32 cmd;
>    NvU32 reply;
>    char versionString[64];
>} nv_ioctl_rm_api_version_t;
># 201 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct nv_ioctl_query_device_intr
>{
>    NvU32 intrStatus __attribute__ ((aligned (4)));
>    NvU32 status;
>} nv_ioctl_query_device_intr;
>
>
>
>
>
>typedef struct nv_ioctl_sys_params
>{
>    NvU64 memblock_size __attribute__ ((aligned (8)));
>} nv_ioctl_sys_params_t;
>
>
>typedef struct nv_ioctl_numa_info
>{
>    NvS32 nid;
>    NvS32 status;
>    NvU64 memblock_size __attribute__ ((aligned (8)));
>    NvU64 numa_mem_addr __attribute__ ((aligned (8)));
>    NvU64 numa_mem_size __attribute__ ((aligned (8)));
>} nv_ioctl_numa_info_t;
>
>
>typedef struct nv_ioctl_set_numa_status
>{
>    NvS32 status;
>} nv_ioctl_set_numa_status_t;
># 242 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>extern const char *pNVRM_ID;
>
>
>
>
>
>typedef union
>{
>    volatile NvV8 Reg008[1];
>    volatile NvV16 Reg016[1];
>    volatile NvV32 Reg032[1];
>} nv_hwreg_t, * nv_phwreg_t;
># 271 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct
>{
>    NvU64 cpu_address;
>    NvU64 bus_address;
>    NvU64 strapped_size;
>    NvU64 size;
>    NvU32 offset;
>    NvU32 *map;
>    nv_phwreg_t map_u;
>} nv_aperture_t;
>
>typedef struct
>{
>    char *node;
>    char *name;
>    NvU32 *data;
>} nv_parm_t;
># 305 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>typedef struct nvidia_stack_s
>{
>    NvU32 size;
>    void *top;
>    NvU8 stack[((1 << 12) * 3)-16] __attribute__ ((aligned(16)));
>} nvidia_stack_t;
>
>
>
>
>typedef nvidia_stack_t nv_stack_t;
>
>
>
>
>
>
>typedef struct nv_event_s
>{
>    NvHandle hParent;
>    NvHandle hObject;
>    NvU32 index;
>    void *file;
>    NvHandle handle;
>    NvU32 fd;
>    struct nv_event_s *next;
>} nv_event_t;
>
>
>
>
>typedef struct nv_fd_memdesc_s
>{
>    NvBool bValid;
>    NvHandle hParent;
>    NvHandle hMemory;
>} nv_fd_memdesc_t;
>
>typedef struct nv_kern_mapping_s
>{
>    void *addr;
>    NvU64 size;
>    NvU32 modeFlag;
>    struct nv_kern_mapping_s *next;
>} nv_kern_mapping_t;
>
>typedef struct nv_usermap_access_params_s
>{
>    NvU64 addr;
>    NvU64 size;
>    NvU64 mmap_start;
>    NvU64 mmap_size;
>    NvU64 access_start;
>    NvU64 access_size;
>    NvU64 remap_prot_extra;
>} nv_usermap_access_params_t;
>
>
>
>
>typedef struct nv_alloc_mapping_context_s {
>    void *alloc;
>    NvU64 page_index;
>    NvU64 mmap_start;
>    NvU64 mmap_size;
>    NvU64 access_start;
>    NvU64 access_size;
>    NvU64 remap_prot_extra;
>    NvU32 prot;
>    NvBool bValid;
>} nv_alloc_mapping_context_t;
>
>
>
>
>
>typedef struct
>{
>    void *priv;
>    void *os_state;
>
>    int flags;
>
>
>    nv_pci_info_t pci_info;
>    NvU16 subsystem_id;
>    NvU16 subsystem_vendor;
>    NvU32 gpu_id;
>    NvU32 iovaspace_id;
>    struct
>    {
>        NvBool bValid;
>        NvU8 uuid[(16)];
>    } nv_gpu_uuid_cache;
>    void *handle;
>
>    NvU32 pci_cfg_space[16];
>
>
>    nv_aperture_t bars[3];
>    nv_aperture_t *regs;
>    nv_aperture_t *fb, ud;
>
>    NvU32 interrupt_line;
>
>    NvBool primary_vga;
>
>    NvU32 sim_env;
>
>    NvU32 rc_timer_enabled;
>
>
>    nv_event_t *event_list;
>
>
>    void *event_spinlock;
>
>    nv_kern_mapping_t *kern_mappings;
>
>
>    NvU64 dma_addressable_start;
>    NvU64 dma_addressable_limit;
>
>    NvBool nvlink_sysmem_links_enabled;
>} nv_state_t;
>
>
>typedef struct gpuSession *nvgpuSessionHandle_t;
>typedef struct gpuAddressSpace *nvgpuAddressSpaceHandle_t;
>typedef struct gpuChannel *nvgpuChannelHandle_t;
>typedef struct gpuObject *nvgpuObjectHandle_t;
>typedef struct UvmGpuChannelPointers_tag *nvgpuChannelInfo_t;
>typedef struct UvmGpuChannelAllocParams_tag nvgpuChannelAllocParams_t;
>typedef struct UvmGpuCaps_tag *nvgpuCaps_t;
>typedef struct UvmGpuAddressSpaceInfo_tag *nvgpuAddressSpaceInfo_t;
>typedef struct UvmGpuAllocInfo_tag *nvgpuAllocInfo_t;
>typedef struct UvmGpuP2PCapsParams_tag *nvgpuP2PCapsParams_t;
>typedef struct gpuVaAllocInfo *nvgpuVaAllocInfo_t;
>typedef struct gpuMapInfo *nvgpuMapInfo_t;
>typedef struct UvmGpuFbInfo_tag *nvgpuFbInfo_t;
>typedef struct UvmGpuFaultInfo_tag *nvgpuFaultInfo_t;
>typedef struct UvmGpuAccessCntrInfo_tag *nvgpuAccessCntrInfo_t;
>typedef struct UvmGpuAccessCntrConfig_tag *nvgpuAccessCntrConfig_t;
>typedef struct UvmGpuInfo_tag *nvgpuInfo_t;
>typedef struct gpuPmaAllocationOptions *nvgpuPmaAllocationOptions_t;
>typedef struct UvmGpuMemoryInfo_tag *nvgpuMemoryInfo_t;
>typedef struct UvmGpuExternalMappingInfo_tag *nvgpuExternalMappingInfo_t;
>typedef struct UvmGpuChannelResourceInfo_tag *nvgpuChannelResourceInfo_t;
>typedef struct UvmGpuChannelInstanceInfo_tag *nvgpuChannelInstanceInfo_t;
>typedef struct UvmGpuChannelResourceBindParams_tag *nvgpuChannelResourceBindParams_t;
>typedef NV_STATUS (*nvPmaEvictPagesCallback)(void *, NvU32, NvU64 *, NvU32, NvU64, NvU64);
>typedef NV_STATUS (*nvPmaEvictRangeCallback)(void *, NvU64, NvU64);
># 561 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) NvBool IS_REG_OFFSET(nv_state_t *nv, NvU64 offset, NvU64 length)
>{
>    return ((offset >= nv->regs->cpu_address) &&
>
>            ((offset + (length - 1)) >= offset) &&
>
>            ((offset + (length - 1)) <= (nv->regs->cpu_address + (nv->regs->size - 1))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) NvBool IS_FB_OFFSET(nv_state_t *nv, NvU64 offset, NvU64 length)
>{
>    return ((nv->fb) && (offset >= nv->fb->cpu_address) &&
>
>             ((offset + (length - 1)) >= offset) &&
>
>             ((offset + (length - 1)) <= (nv->fb->cpu_address + (nv->fb->size - 1))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) NvBool IS_UD_OFFSET(nv_state_t *nv, NvU64 offset, NvU64 length)
>{
>    return ((nv->ud.cpu_address != 0) && (nv->ud.size != 0) &&
>            (offset >= nv->ud.cpu_address) &&
>
>            ((offset + (length - 1)) >= offset) &&
>
>            ((offset + (length - 1)) <= (nv->ud.cpu_address + (nv->ud.size - 1))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) NvBool IS_IMEM_OFFSET(nv_state_t *nv, NvU64 offset, NvU64 length)
>{
>    return ((nv->bars[2].cpu_address != 0) &&
>            (nv->bars[2].size != 0) &&
>            (offset >= nv->bars[2].cpu_address) &&
>
>            ((offset + (length - 1)) >= offset) &&
>
>            ((offset + (length - 1)) <= (nv->bars[2].cpu_address +
>                                         (nv->bars[2].size - 1))));
>}
># 657 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>void* nv_alloc_kernel_mapping (nv_state_t *, void *, NvU64, NvU32, NvU64, void **);
>NV_STATUS nv_free_kernel_mapping (nv_state_t *, void *, void *, void *);
>NV_STATUS nv_alloc_user_mapping (nv_state_t *, void *, NvU64, NvU32, NvU64, NvU32, NvU64 *, void **);
>NV_STATUS nv_free_user_mapping (nv_state_t *, void *, NvU64, void *);
>NV_STATUS nv_add_mapping_context_to_file (nv_state_t *, nv_usermap_access_params_t*, NvU32, void *, NvU64, NvU32);
>
>NvU64 nv_get_kern_phys_address (NvU64);
>NvU64 nv_get_user_phys_address (NvU64);
>nv_state_t* nv_get_adapter_state (NvU32, NvU8, NvU8);
>nv_state_t* nv_get_ctl_state (void);
>
>void nv_set_dma_address_size (nv_state_t *, NvU32 );
>
>NV_STATUS nv_alias_pages (nv_state_t *, NvU32, NvU32, NvU32, NvU64, NvU64 *, void **);
>NV_STATUS nv_alloc_pages (nv_state_t *, NvU32, NvBool, NvU32, NvBool, NvU64 *, void **);
>NV_STATUS nv_free_pages (nv_state_t *, NvU32, NvBool, NvU32, void *);
>
>NV_STATUS nv_register_user_pages (nv_state_t *, NvU64, NvU64 *, void **);
>NV_STATUS nv_unregister_user_pages (nv_state_t *, NvU64, void **);
>
>NV_STATUS nv_register_peer_io_mem (nv_state_t *, NvU64 *, NvU64, void **);
>void nv_unregister_peer_io_mem (nv_state_t *, void *);
>
>NV_STATUS nv_dma_map_pages (nv_state_t *, NvU64, NvU64 *, NvBool, void **);
>NV_STATUS nv_dma_unmap_pages (nv_state_t *, NvU64, NvU64 *, void **);
>
>NV_STATUS nv_dma_map_alloc (nv_state_t *, NvU64, NvU64 *, NvBool, void **);
>NV_STATUS nv_dma_unmap_alloc (nv_state_t *, NvU64, NvU64 *, void **);
>
>NV_STATUS nv_dma_map_peer (nv_state_t *, nv_state_t *, NvU8, NvU64, NvU64 *);
>void nv_dma_unmap_peer (nv_state_t *, NvU64, NvU64);
>
>NV_STATUS nv_dma_map_mmio (nv_state_t *, NvU64, NvU64 *);
>void nv_dma_unmap_mmio (nv_state_t *, NvU64, NvU64);
>
>NvS32 nv_start_rc_timer (nv_state_t *);
>NvS32 nv_stop_rc_timer (nv_state_t *);
>
>void nv_post_event (nv_state_t *, nv_event_t *, NvHandle, NvU32, NvBool);
>NvS32 nv_get_event (nv_state_t *, void *, nv_event_t *, NvU32 *);
>
>void nv_verify_pci_config (nv_state_t *, NvS32);
>
>void* nv_i2c_add_adapter (nv_state_t *, NvU32);
>NvS32 nv_i2c_del_adapter (nv_state_t *, void *);
>
>void nv_acpi_methods_init (NvU32 *);
>void nv_acpi_methods_uninit (void);
>
>NV_STATUS nv_acpi_method (NvU32, NvU32, NvU32, void *, NvU16, NvU32 *, void *, NvU16 *);
>NV_STATUS nv_acpi_dsm_method (nv_state_t *, NvU8 *, NvU32, NvU32, void *, NvU16, NvU32 *, void *, NvU16 *);
>NV_STATUS nv_acpi_ddc_method (nv_state_t *, void *, NvU32 *);
>NV_STATUS nv_acpi_dod_method (nv_state_t *, NvU32 *, NvU32 *);
>NV_STATUS nv_acpi_rom_method (nv_state_t *, NvU32 *, NvU32 *);
>NV_STATUS nv_log_error (nv_state_t *, NvU32, const char *, va_list);
>
>NvU64 nv_get_dma_start_address (nv_state_t *);
>NV_STATUS nv_set_primary_vga_status(nv_state_t *);
>NV_STATUS nv_pci_trigger_recovery (nv_state_t *);
>NvBool nv_requires_dma_remap (nv_state_t *);
>
>
>NvBool nv_is_virtualized_system (nv_stack_t *);
>
>
>nv_fd_memdesc_t* nv_get_fd_memdesc (void *);
>NV_STATUS nv_add_fd_memdesc_to_fd (NvU32, const nv_fd_memdesc_t*);
>
>NV_STATUS nv_export_rm_object_to_fd (NvHandle, NvS32);
>NV_STATUS nv_import_rm_object_from_fd (NvS32, NvHandle *);
>
>NV_STATUS nv_get_device_memory_config(nv_state_t *, NvU32 *, NvU32 *, NvU32 *, NvU32 *, NvS32 *);
>
>NV_STATUS nv_get_ibmnpu_genreg_info(nv_state_t *, NvU64 *, NvU64 *);
>NV_STATUS nv_get_ibmnpu_relaxed_ordering_mode(nv_state_t *nv, NvBool *mode);
>
>
>
>
>
>void nv_register_backlight (nv_state_t *, NvU32, NvU32);
>void nv_unregister_backlight (nv_state_t *);
># 747 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv.h"
>NvS32 rm_init_rm (nvidia_stack_t *);
>NvS32 rm_shutdown_rm (nvidia_stack_t *);
>NvS32 rm_init_private_state (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_free_private_state (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_init_adapter (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_disable_adapter (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_shutdown_adapter (nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_validate_mmap_request (nvidia_stack_t *, nv_state_t *, void *, NvU64, NvU64, NvU32 *, void **, NvU64 *);
>NV_STATUS rm_acquire_api_lock (nvidia_stack_t *);
>NV_STATUS rm_release_api_lock (nvidia_stack_t *);
>NV_STATUS rm_ioctl (nvidia_stack_t *, nv_state_t *, void *, NvU32, void *, NvU32);
>NvS32 rm_isr (nvidia_stack_t *, nv_state_t *, NvU32 *);
>void rm_isr_bh (nvidia_stack_t *, nv_state_t *);
>void rm_isr_bh_unlocked (nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_power_management (nvidia_stack_t *, nv_state_t *, NvU32, NvU32);
>NV_STATUS rm_save_low_res_mode (nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_get_vbios_version (nvidia_stack_t *, nv_state_t *, NvU32 *, NvU32 *, NvU32 *, NvU32 *, NvU32 *);
>NV_STATUS rm_get_gpu_uuid (nvidia_stack_t *, nv_state_t *, NvU8 **, NvU32 *);
>NV_STATUS rm_get_gpu_uuid_raw (nvidia_stack_t *, nv_state_t *, NvU8 **, NvU32 *);
>void rm_free_unused_clients (nvidia_stack_t *, nv_state_t *, void *);
>void rm_unbind_lock (nvidia_stack_t *, nv_state_t *);
>void rm_free_exported_object (nvidia_stack_t *, NvHandle);
>NV_STATUS rm_read_registry_dword (nvidia_stack_t *, nv_state_t *, NvU8 *, NvU8 *, NvU32 *);
>NV_STATUS rm_write_registry_dword (nvidia_stack_t *, nv_state_t *, NvU8 *, NvU8 *, NvU32);
>NV_STATUS rm_read_registry_binary (nvidia_stack_t *, nv_state_t *, NvU8 *, NvU8 *, NvU8 *, NvU32 *);
>NV_STATUS rm_write_registry_binary (nvidia_stack_t *, nv_state_t *, NvU8 *, NvU8 *, NvU8 *, NvU32);
>NV_STATUS rm_write_registry_string (nvidia_stack_t *, nv_state_t *, NvU8 *, NvU8 *, const char *, NvU32);
>void rm_parse_option_string (nvidia_stack_t *, const char *);
>char* rm_remove_spaces (const char *);
>char* rm_string_token (char **, const char);
>
>NV_STATUS rm_run_rc_callback (nvidia_stack_t *, nv_state_t *);
>void rm_execute_work_item (nvidia_stack_t *, void *);
>NV_STATUS rm_get_device_name (nvidia_stack_t *, nv_state_t *, NvU16, NvU16, NvU16, NvU32, NvU8 *);
>
>NvU64 nv_rdtsc (void);
>
>void rm_register_compatible_ioctls (nvidia_stack_t *);
>void rm_unregister_compatible_ioctls (nvidia_stack_t *);
>
>NvS32 rm_is_legacy_device (nvidia_stack_t *, NvU16, NvU16, NvU16, NvS32);
>NV_STATUS rm_is_supported_device (nvidia_stack_t *, nv_state_t *);
>
>void rm_check_pci_config_space (nvidia_stack_t *, nv_state_t *nv, NvS32, NvS32, NvS32);
>
>NV_STATUS rm_i2c_remove_adapters (nvidia_stack_t *, nv_state_t *);
>NvBool rm_i2c_is_smbus_capable (nvidia_stack_t *, nv_state_t *, void *);
>NV_STATUS rm_i2c_transfer (nvidia_stack_t *, nv_state_t *, void *, NvU8, NvU8, NvU8, NvU32, NvU8 *);
>
>NV_STATUS rm_perform_version_check (nvidia_stack_t *, void *, NvU32);
>
>NV_STATUS rm_system_event (nvidia_stack_t *, NvU32, NvU32);
>
>void rm_disable_gpu_state_persistence (nvidia_stack_t *sp, nv_state_t *);
>NV_STATUS rm_p2p_init_mapping (nvidia_stack_t *, NvU64, NvU64 *, NvU64 *, NvU64 *, NvU64 *, NvU64, NvU64, NvU64, NvU64, void (*)(void *), void *);
>NV_STATUS rm_p2p_destroy_mapping (nvidia_stack_t *, NvU64);
>NV_STATUS rm_p2p_get_pages (nvidia_stack_t *, NvU64, NvU32, NvU64, NvU64, NvU64 *, NvU32 *, NvU32 *, NvU32 *, NvU8 **, void *, void (*)(void *), void *);
>NV_STATUS rm_p2p_put_pages (nvidia_stack_t *, NvU64, NvU32, NvU64, void *);
>NV_STATUS rm_p2p_dma_map_pages (nvidia_stack_t *, nv_state_t *, NvU8 *, NvU32, NvU32, NvU64 *, void **);
>NV_STATUS rm_p2p_dma_unmap_pages (nvidia_stack_t *, nv_state_t *, NvU32, NvU32, NvU64 *, void *);
>NV_STATUS rm_get_cpu_type (nvidia_stack_t *, nv_cpu_type_t *);
>NV_STATUS rm_log_gpu_crash (nv_stack_t *, nv_state_t *);
>
>NV_STATUS rm_gpu_ops_create_session (nvidia_stack_t *, nvgpuSessionHandle_t *);
>NV_STATUS rm_gpu_ops_destroy_session (nvidia_stack_t *, nvgpuSessionHandle_t);
>NV_STATUS rm_gpu_ops_address_space_create(nvidia_stack_t *, nvgpuSessionHandle_t, const NvProcessorUuid *, unsigned long long, unsigned long long, nvgpuAddressSpaceHandle_t *, nvgpuAddressSpaceInfo_t);
>NV_STATUS rm_gpu_ops_dup_address_space(nvidia_stack_t *, nvgpuSessionHandle_t, const NvProcessorUuid *, NvHandle, NvHandle, nvgpuAddressSpaceHandle_t *, nvgpuAddressSpaceInfo_t);
>NV_STATUS rm_gpu_ops_address_space_destroy(nvidia_stack_t *, nvgpuAddressSpaceHandle_t);
>NV_STATUS rm_gpu_ops_memory_alloc_fb(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvLength, NvU64 *, nvgpuAllocInfo_t);
>
>NV_STATUS rm_gpu_ops_pma_alloc_pages(nvidia_stack_t *, void *, NvLength, NvU32 , nvgpuPmaAllocationOptions_t, NvU64 *);
>NV_STATUS rm_gpu_ops_pma_free_pages(nvidia_stack_t *, void *, NvU64 *, NvLength , NvU32, NvU32);
>NV_STATUS rm_gpu_ops_pma_pin_pages(nvidia_stack_t *, void *, NvU64 *, NvLength , NvU32, NvU32);
>NV_STATUS rm_gpu_ops_pma_unpin_pages(nvidia_stack_t *, void *, NvU64 *, NvLength , NvU32);
>NV_STATUS rm_gpu_ops_get_pma_object(nvidia_stack_t *, const NvProcessorUuid *, void **);
>NV_STATUS rm_gpu_ops_pma_register_callbacks(nvidia_stack_t *sp, void *, nvPmaEvictPagesCallback, nvPmaEvictRangeCallback, void *);
>void rm_gpu_ops_pma_unregister_callbacks(nvidia_stack_t *sp, void *);
>
>NV_STATUS rm_gpu_ops_memory_alloc_sys(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvLength, NvU64 *, nvgpuAllocInfo_t);
>
>NV_STATUS rm_gpu_ops_get_p2p_caps(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuAddressSpaceHandle_t, nvgpuP2PCapsParams_t);
>
>NV_STATUS rm_gpu_ops_memory_cpu_map(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvU64, NvLength, void **, NvU32);
>NV_STATUS rm_gpu_ops_memory_cpu_ummap(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, void*);
>NV_STATUS rm_gpu_ops_channel_allocate(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuChannelHandle_t *, const nvgpuChannelAllocParams_t *, nvgpuChannelInfo_t);
>NV_STATUS rm_gpu_ops_channel_destroy(nvidia_stack_t *, nvgpuChannelHandle_t);
>NV_STATUS rm_gpu_ops_copy_engine_alloc(nvidia_stack_t *, nvgpuChannelHandle_t, NvU32, nvgpuObjectHandle_t *, nvgpuChannelInfo_t);
>NV_STATUS rm_gpu_ops_memory_free(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvU64);
>NV_STATUS rm_gpu_ops_query_caps(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuCaps_t);
>NV_STATUS rm_gpu_ops_get_gpu_info(nvidia_stack_t *, const NvProcessorUuid *pUuid, nvgpuInfo_t);
>NV_STATUS rm_gpu_ops_service_device_interrupts_rm(nvidia_stack_t *, nvgpuAddressSpaceHandle_t);
>NV_STATUS rm_gpu_ops_dup_allocation(nvidia_stack_t *, NvHandle, nvgpuAddressSpaceHandle_t, NvU64, nvgpuAddressSpaceHandle_t, NvU64*, NvBool);
>
>NV_STATUS rm_gpu_ops_dup_memory (nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvHandle, NvHandle, NvHandle *, nvgpuMemoryInfo_t);
>
>NV_STATUS rm_gpu_ops_free_duped_handle(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvHandle);
>NV_STATUS rm_gpu_ops_get_fb_info(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuFbInfo_t);
>NV_STATUS rm_gpu_ops_own_page_fault_intr(nvidia_stack_t *, const NvProcessorUuid *, NvBool);
>NV_STATUS rm_gpu_ops_init_fault_info(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuFaultInfo_t);
>NV_STATUS rm_gpu_ops_destroy_fault_info(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuFaultInfo_t);
>NV_STATUS rm_gpu_ops_get_non_replayable_faults(nvidia_stack_t *, nvgpuFaultInfo_t, void *, NvU32 *);
>NV_STATUS rm_gpu_ops_has_pending_non_replayable_faults(nvidia_stack_t *, nvgpuFaultInfo_t, NvBool *);
>NV_STATUS rm_gpu_ops_init_access_cntr_info(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuAccessCntrInfo_t);
>NV_STATUS rm_gpu_ops_destroy_access_cntr_info(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuAccessCntrInfo_t);
>NV_STATUS rm_gpu_ops_own_access_cntr_intr(nvidia_stack_t *, nvgpuSessionHandle_t, nvgpuAccessCntrInfo_t, NvBool);
>NV_STATUS rm_gpu_ops_enable_access_cntr(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuAccessCntrInfo_t, nvgpuAccessCntrConfig_t);
>NV_STATUS rm_gpu_ops_disable_access_cntr(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuAccessCntrInfo_t);
>NV_STATUS rm_gpu_ops_set_page_directory (nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvU64, unsigned, NvBool);
>NV_STATUS rm_gpu_ops_unset_page_directory (nvidia_stack_t *, nvgpuAddressSpaceHandle_t);
>NV_STATUS rm_gpu_ops_p2p_object_create(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, nvgpuAddressSpaceHandle_t, NvHandle *);
>void rm_gpu_ops_p2p_object_destroy(nvidia_stack_t *, nvgpuSessionHandle_t, NvHandle);
>NV_STATUS rm_gpu_ops_get_external_alloc_ptes(nvidia_stack_t*, nvgpuAddressSpaceHandle_t, NvHandle, NvU64, NvU64, nvgpuExternalMappingInfo_t);
>NV_STATUS rm_gpu_ops_retain_channel(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvHandle, NvHandle, void **, nvgpuChannelInstanceInfo_t);
>NV_STATUS rm_gpu_ops_retain_channel_resources(nvidia_stack_t *, void *, nvgpuChannelResourceInfo_t);
>NV_STATUS rm_gpu_ops_bind_channel_resources(nvidia_stack_t *, void *, nvgpuChannelResourceBindParams_t);
>void rm_gpu_ops_release_channel(nvidia_stack_t *, void *);
>void rm_gpu_ops_release_channel_resources(nvidia_stack_t *, NvP64*, NvU32);
>void rm_gpu_ops_stop_channel(nvidia_stack_t *, void *, NvBool);
>NV_STATUS rm_gpu_ops_get_channel_resource_ptes(nvidia_stack_t *, nvgpuAddressSpaceHandle_t, NvP64, NvU64, NvU64, nvgpuExternalMappingInfo_t);
>void rm_kernel_rmapi_op(nvidia_stack_t *sp, void *ops_cmd);
>NvBool rm_get_device_remove_flag(nvidia_stack_t *sp, NvU32 gpu_id);
>NV_STATUS rm_gpu_copy_mmu_faults(nvidia_stack_t *, nv_state_t *, NvU32 *);
>NV_STATUS rm_gpu_copy_mmu_faults_unlocked(nvidia_stack_t *, nv_state_t *, NvU32 *);
>NV_STATUS rm_gpu_need_4k_page_isolation(nv_state_t *, NvBool *);
>NvBool rm_is_chipset_io_coherent(nv_stack_t *);
>NvBool rm_init_event_locks(nvidia_stack_t *, nv_state_t *);
>void rm_destroy_event_locks(nvidia_stack_t *, nv_state_t *);
>void rm_get_gpu_numa_info(nvidia_stack_t *, nv_state_t *, NvS32 *, NvU64 *, NvU64 *);
>NV_STATUS rm_set_backlight(nvidia_stack_t *, nv_state_t *, NvU32, NvU32);
>NV_STATUS rm_get_backlight(nvidia_stack_t *, nv_state_t *, NvU32, NvU32 *);
>NV_STATUS rm_gpu_numa_online(nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_gpu_numa_offline(nvidia_stack_t *, nv_state_t *);
>
>
>NV_STATUS nv_vgpu_create_request(nvidia_stack_t *, nv_state_t *, NvU8 *, NvU32, NvU16 *);
>NV_STATUS nv_vgpu_delete(nvidia_stack_t *, NvU8 *, NvU16);
>NV_STATUS nv_vgpu_get_type_ids(nvidia_stack_t *, nv_state_t *, NvU32 *, NvU32 **);
>NV_STATUS nv_vgpu_get_type_info(nvidia_stack_t *, nv_state_t *, NvU32, NvU8 *, int);
>NV_STATUS nv_vgpu_get_bar_info(nvidia_stack_t *, nv_state_t *, NvU8 *, NvU64 *, NvU32, void *, void **);
>NV_STATUS nv_vgpu_start(nvidia_stack_t *, NvU8 *, void *, NvS32 *, NvU8 *, NvU32, NvU8 *);
>NV_STATUS nv_vgpu_get_sparse_mmap(nvidia_stack_t *, nv_state_t *, NvU8 *, NvU64 **, NvU64 **, NvU32 *);
>NV_STATUS nv_vgpu_update_request(nvidia_stack_t *, NvU8 *);
>NV_STATUS nv_gpu_bind_event(nvidia_stack_t *);
>
>NV_STATUS nv_get_usermap_access_params(nv_state_t*, nv_usermap_access_params_t*);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) int nv_count_bits(NvU64 word)
>{
>    NvU64 bits;
>
>    bits = (word & 0x5555555555555555ULL) + ((word >> 1) & 0x5555555555555555ULL);
>    bits = (bits & 0x3333333333333333ULL) + ((bits >> 2) & 0x3333333333333333ULL);
>    bits = (bits & 0x0f0f0f0f0f0f0f0fULL) + ((bits >> 4) & 0x0f0f0f0f0f0f0f0fULL);
>    bits = (bits & 0x00ff00ff00ff00ffULL) + ((bits >> 8) & 0x00ff00ff00ff00ffULL);
>    bits = (bits & 0x0000ffff0000ffffULL) + ((bits >> 16) & 0x0000ffff0000ffffULL);
>    bits = (bits & 0x00000000ffffffffULL) + ((bits >> 32) & 0x00000000ffffffffULL);
>
>    return (int)(bits);
>}
># 17 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-lock.h" 1
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-lock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 1
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/typecheck.h" 1
># 55 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/linkage.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler_types.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/linkage.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stringify.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/linkage.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/export.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/export.h"
>extern struct module __this_module;
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/export.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler.h" 1
># 250 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void *offset_to_ptr(const int *off)
>{
> return (void *)((unsigned long)off + *off);
>}
># 266 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler.h"
># 1 "./arch/x86/include/generated/asm/rwonce.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/rwonce.h" 1
># 26 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/rwonce.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan-checks.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/types.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/types.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/types.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/int-ll64.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/int-ll64.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/int-ll64.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/int-ll64.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bitsperlong.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bitsperlong.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitsperlong.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/bitsperlong.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitsperlong.h" 2
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bitsperlong.h" 2
># 13 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/int-ll64.h" 2
>
>
>
>
>
>
>
>typedef __signed__ char __s8;
>typedef unsigned char __u8;
>
>typedef __signed__ short __s16;
>typedef unsigned short __u16;
>
>typedef __signed__ int __s32;
>typedef unsigned int __u32;
>
>
>__extension__ typedef __signed__ long long __s64;
>__extension__ typedef unsigned long long __u64;
># 12 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/int-ll64.h" 2
>
>
>
>
>typedef __s8 s8;
>typedef __u8 u8;
>typedef __s16 s16;
>typedef __u16 u16;
>typedef __s32 s32;
>typedef __u32 u32;
>typedef __s64 s64;
>typedef __u64 u64;
># 8 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/types.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/types.h" 2
># 14 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/posix_types.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stddef.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/stddef.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/stddef.h" 2
>
>
>
>
>enum {
> false = 0,
> true = 1
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/posix_types.h" 2
># 25 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/posix_types.h"
>typedef struct {
> unsigned long fds_bits[1024 / (8 * sizeof(long))];
>} __kernel_fd_set;
>
>
>typedef void (*__kernel_sighandler_t)(int);
>
>
>typedef int __kernel_key_t;
>typedef int __kernel_mqd_t;
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/posix_types.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/posix_types_64.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/posix_types_64.h"
>typedef unsigned short __kernel_old_uid_t;
>typedef unsigned short __kernel_old_gid_t;
>
>
>typedef unsigned long __kernel_old_dev_t;
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/posix_types.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/posix_types.h"
>typedef long __kernel_long_t;
>typedef unsigned long __kernel_ulong_t;
>
>
>
>typedef __kernel_ulong_t __kernel_ino_t;
>
>
>
>typedef unsigned int __kernel_mode_t;
>
>
>
>typedef int __kernel_pid_t;
>
>
>
>typedef int __kernel_ipc_pid_t;
>
>
>
>typedef unsigned int __kernel_uid_t;
>typedef unsigned int __kernel_gid_t;
>
>
>
>typedef __kernel_long_t __kernel_suseconds_t;
>
>
>
>typedef int __kernel_daddr_t;
>
>
>
>typedef unsigned int __kernel_uid32_t;
>typedef unsigned int __kernel_gid32_t;
># 72 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/posix_types.h"
>typedef __kernel_ulong_t __kernel_size_t;
>typedef __kernel_long_t __kernel_ssize_t;
>typedef __kernel_long_t __kernel_ptrdiff_t;
>
>
>
>
>typedef struct {
> int val[2];
>} __kernel_fsid_t;
>
>
>
>
>
>typedef __kernel_long_t __kernel_off_t;
>typedef long long __kernel_loff_t;
>typedef __kernel_long_t __kernel_old_time_t;
>
>
>
>typedef long long __kernel_time64_t;
>typedef __kernel_long_t __kernel_clock_t;
>typedef int __kernel_timer_t;
>typedef int __kernel_clockid_t;
>typedef char * __kernel_caddr_t;
>typedef unsigned short __kernel_uid16_t;
>typedef unsigned short __kernel_gid16_t;
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/posix_types_64.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/posix_types.h" 2
># 37 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/posix_types.h" 2
># 15 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/types.h" 2
># 29 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/types.h"
>typedef __u16 __le16;
>typedef __u16 __be16;
>typedef __u32 __le32;
>typedef __u32 __be32;
>typedef __u64 __le64;
>typedef __u64 __be64;
>
>typedef __u16 __sum16;
>typedef __u32 __wsum;
># 52 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/types.h"
>typedef unsigned __poll_t;
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/types.h" 2
>
>
>
>
>
>
>typedef u32 __kernel_dev_t;
>
>typedef __kernel_fd_set fd_set;
>typedef __kernel_dev_t dev_t;
>typedef __kernel_ulong_t ino_t;
>typedef __kernel_mode_t mode_t;
>typedef unsigned short umode_t;
>typedef u32 nlink_t;
>typedef __kernel_off_t off_t;
>typedef __kernel_pid_t pid_t;
>typedef __kernel_daddr_t daddr_t;
>typedef __kernel_key_t key_t;
>typedef __kernel_suseconds_t suseconds_t;
>typedef __kernel_timer_t timer_t;
>typedef __kernel_clockid_t clockid_t;
>typedef __kernel_mqd_t mqd_t;
>
>typedef _Bool bool;
>
>typedef __kernel_uid32_t uid_t;
>typedef __kernel_gid32_t gid_t;
>typedef __kernel_uid16_t uid16_t;
>typedef __kernel_gid16_t gid16_t;
>
>typedef unsigned long uintptr_t;
>
>
>
>typedef __kernel_old_uid_t old_uid_t;
>typedef __kernel_old_gid_t old_gid_t;
>
>
>
>typedef __kernel_loff_t loff_t;
># 55 "/usr/src/linux-5.14.21-150500.53/include/linux/types.h"
>typedef __kernel_size_t size_t;
>
>
>
>
>typedef __kernel_ssize_t ssize_t;
>
>
>
>
>typedef __kernel_ptrdiff_t ptrdiff_t;
>
>
>
>
>typedef __kernel_clock_t clock_t;
>
>
>
>
>typedef __kernel_caddr_t caddr_t;
>
>
>
>typedef unsigned char u_char;
>typedef unsigned short u_short;
>typedef unsigned int u_int;
>typedef unsigned long u_long;
>
>
>typedef unsigned char unchar;
>typedef unsigned short ushort;
>typedef unsigned int uint;
>typedef unsigned long ulong;
>
>
>
>
>typedef u8 u_int8_t;
>typedef s8 int8_t;
>typedef u16 u_int16_t;
>typedef s16 int16_t;
>typedef u32 u_int32_t;
>typedef s32 int32_t;
>
>
>
>typedef u8 uint8_t;
>typedef u16 uint16_t;
>typedef u32 uint32_t;
>
>
>typedef u64 uint64_t;
>typedef u64 u_int64_t;
>typedef s64 int64_t;
># 125 "/usr/src/linux-5.14.21-150500.53/include/linux/types.h"
>typedef u64 sector_t;
>typedef u64 blkcnt_t;
># 143 "/usr/src/linux-5.14.21-150500.53/include/linux/types.h"
>typedef u64 dma_addr_t;
>
>
>
>
>typedef unsigned int gfp_t;
>typedef unsigned int slab_flags_t;
>typedef unsigned int fmode_t;
>
>
>typedef u64 phys_addr_t;
>
>
>
>
>typedef phys_addr_t resource_size_t;
>
>
>
>
>
>typedef unsigned long irq_hw_number_t;
>
>typedef struct {
> int counter;
>} atomic_t;
>
>
>
>
>typedef struct {
> s64 counter;
>} atomic64_t;
>
>
>struct list_head {
> struct list_head *next, *prev;
>};
>
>struct hlist_head {
> struct hlist_node *first;
>};
>
>struct hlist_node {
> struct hlist_node *next, **pprev;
>};
>
>struct ustat {
> __kernel_daddr_t f_tfree;
>
>
>
> unsigned long f_tinode;
>
> char f_fname[6];
> char f_fpack[6];
>};
># 220 "/usr/src/linux-5.14.21-150500.53/include/linux/types.h"
>struct callback_head {
> struct callback_head *next;
> void (*func)(struct callback_head *head);
>} __attribute__((aligned(sizeof(void *))));
>
>
>typedef void (*rcu_callback_t)(struct callback_head *head);
>typedef void (*call_rcu_func_t)(struct callback_head *head, rcu_callback_t func);
>
>typedef void (*swap_r_func_t)(void *a, void *b, int size, const void *priv);
>typedef void (*swap_func_t)(void *a, void *b, int size);
>
>typedef int (*cmp_r_func_t)(const void *a, const void *b, const void *priv);
>typedef int (*cmp_func_t)(const void *a, const void *b);
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan-checks.h" 2
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan-checks.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) bool __kasan_check_read(const volatile void *p, unsigned int size)
>{
> return true;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) bool __kasan_check_write(const volatile void *p, unsigned int size)
>{
> return true;
>}
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan-checks.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) bool kasan_check_read(const volatile void *p, unsigned int size)
>{
> return true;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) bool kasan_check_write(const volatile void *p, unsigned int size)
>{
> return true;
>}
># 27 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/rwonce.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kcsan-checks.h" 1
># 148 "/usr/src/linux-5.14.21-150500.53/include/linux/kcsan-checks.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void __kcsan_check_access(const volatile void *ptr, size_t size,
>     int type) { }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_disable_current(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_enable_current(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_enable_current_nowarn(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_nestable_atomic_begin(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_nestable_atomic_end(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_flat_atomic_begin(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_flat_atomic_end(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_atomic_next(int n) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_set_access_mask(unsigned long mask) { }
>
>struct kcsan_scoped_access { };
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) struct kcsan_scoped_access *
>kcsan_begin_scoped_access(const volatile void *ptr, size_t size, int type,
>     struct kcsan_scoped_access *sa) { return sa; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_end_scoped_access(struct kcsan_scoped_access *sa) { }
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/kcsan-checks.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void kcsan_check_access(const volatile void *ptr, size_t size,
>          int type) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void __kcsan_enable_current(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) void __kcsan_disable_current(void) { }
># 28 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/rwonce.h" 2
># 64 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/rwonce.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) __attribute__((__always_inline__))
>unsigned long __read_once_word_nocheck(const void *addr)
>{
> return (*(const volatile typeof( _Generic((*(unsigned long *)addr), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*(unsigned long *)addr))) *)&(*(unsigned long *)addr));
>}
># 82 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/rwonce.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((__no_instrument_function__)) __attribute__((__always_inline__))
>unsigned long read_word_at_a_time(const void *addr)
>{
> kasan_check_read(addr, 1);
> return *(unsigned long *)addr;
>}
># 1 "./arch/x86/include/generated/asm/rwonce.h" 2
># 267 "/usr/src/linux-5.14.21-150500.53/include/linux/compiler.h" 2
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/export.h" 2
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/export.h"
>struct kernel_symbol {
> int value_offset;
> int name_offset;
> int namespace_offset;
>};
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/linkage.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/linkage.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/linkage.h" 2
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/poison.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/const.h" 1
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/const.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/const.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/vdso/const.h" 2
># 5 "/usr/src/linux-5.14.21-150500.53/include/linux/const.h" 2
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/align.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/limits.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/limits.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/limits.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/limits.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/limits.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/container_of.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/build_bug.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/container_of.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/err.h" 1
>
>
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/errno.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/errno-base.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/errno.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 2
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/err.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/err.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void * __attribute__((__warn_unused_result__)) ERR_PTR(long error)
>{
> return (void *) error;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long __attribute__((__warn_unused_result__)) PTR_ERR( const void *ptr)
>{
> return (long) ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) IS_ERR( const void *ptr)
>{
> return __builtin_expect(!!((unsigned long)(void *)((unsigned long)ptr) >= (unsigned long)-4095), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) IS_ERR_OR_NULL( const void *ptr)
>{
> return __builtin_expect(!!(!ptr), 0) || __builtin_expect(!!((unsigned long)(void *)((unsigned long)ptr) >= (unsigned long)-4095), 0);
>}
># 51 "/usr/src/linux-5.14.21-150500.53/include/linux/err.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void * __attribute__((__warn_unused_result__)) ERR_CAST( const void *ptr)
>{
>
> return (void *) ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) PTR_ERR_OR_ZERO( const void *ptr)
>{
> if (IS_ERR(ptr))
>  return PTR_ERR(ptr);
> else
>  return 0;
>}
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/container_of.h" 2
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bits.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/bits.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/bits.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/kernel.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sysinfo.h" 1
>
>
>
>
>
>
>
>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[20-2*sizeof(__kernel_ulong_t)-sizeof(__u32)];
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/kernel.h" 2
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h"
>extern unsigned int __sw_hweight8(unsigned int w);
>extern unsigned int __sw_hweight16(unsigned int w);
>extern unsigned int __sw_hweight32(unsigned int w);
>extern unsigned long __sw_hweight64(__u64 w);
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/alternative.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/asm.h" 1
># 125 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/asm.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/extable_fixup_types.h" 1
># 126 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/asm.h" 2
># 203 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/asm.h"
>register unsigned long current_stack_pointer asm("rsp");
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/alternative.h" 2
># 62 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/alternative.h"
>struct alt_instr {
> s32 instr_offset;
> s32 repl_offset;
> u16 cpuid;
> u8 instrlen;
> u8 replacementlen;
>} __attribute__((__packed__));
>
>
>
>
>
>extern int alternatives_patched;
>
>extern void alternative_instructions(void);
>extern void apply_alternatives(struct alt_instr *start, struct alt_instr *end);
>extern void apply_retpolines(s32 *start, s32 *end);
>extern void apply_returns(s32 *start, s32 *end);
>
>struct module;
>
>
>extern void alternatives_smp_module_add(struct module *mod, char *name,
>     void *locks, void *locks_end,
>     void *text, void *text_end);
>extern void alternatives_smp_module_del(struct module *mod);
>extern void alternatives_enable_smp(void);
>extern int alternatives_text_reserved(void *start, void *end);
>extern bool skip_smp_alternatives;
># 18 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/rmwcc.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/barrier.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nops.h" 1
># 74 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nops.h"
>extern const unsigned char * const x86_nops[];
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/barrier.h" 2
># 36 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/barrier.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long array_index_mask_nospec(unsigned long index,
>  unsigned long size)
>{
> unsigned long mask;
>
> asm volatile ("cmp %1,%2; sbb %0,%0;"
>   :"=r" (mask)
>   :"g"(size),"r" (index)
>   :"cc");
> return mask;
>}
># 82 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/barrier.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/barrier.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/barrier.h"
># 1 "./arch/x86/include/generated/asm/rwonce.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/barrier.h" 2
># 83 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/barrier.h" 2
># 97 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/barrier.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void weak_wrmsr_fence(void)
>{
> asm volatile("mfence; lfence" : : : "memory");
>}
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
># 51 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_set_bit(long nr, volatile unsigned long *addr)
>{
> if (__builtin_constant_p(nr)) {
>  asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "orb %b1,%0"
>   : "+m" (*(volatile char *) ((void *)(addr) + ((nr)>>3)))
>   : "iq" ((1 << ((nr) & 7)))
>   : "memory");
> } else {
>  asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " " " "btsq" " " " %1,%0"
>   : : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch___set_bit(long nr, volatile unsigned long *addr)
>{
> asm volatile(" " "btsq" " " " %1,%0" : : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_clear_bit(long nr, volatile unsigned long *addr)
>{
> if (__builtin_constant_p(nr)) {
>  asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "andb %b1,%0"
>   : "+m" (*(volatile char *) ((void *)(addr) + ((nr)>>3)))
>   : "iq" (~(1 << ((nr) & 7))));
> } else {
>  asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " " " "btrq" " " " %1,%0"
>   : : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_clear_bit_unlock(long nr, volatile unsigned long *addr)
>{
> __asm__ __volatile__("": : :"memory");
> arch_clear_bit(nr, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch___clear_bit(long nr, volatile unsigned long *addr)
>{
> asm volatile(" " "btrq" " " " %1,%0" : : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr)
>{
> bool negative;
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "andb %2,%1"
>  "\n\t/* output condition code " "s" "*/\n"
>  : "=@cc" "s" (negative), "+m" (*(volatile char *) (addr))
>  : "ir" ((char) ~(1 << nr)) : "memory");
> return negative;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch___clear_bit_unlock(long nr, volatile unsigned long *addr)
>{
> arch___clear_bit(nr, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch___change_bit(long nr, volatile unsigned long *addr)
>{
> asm volatile(" " "btcq" " " " %1,%0" : : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_change_bit(long nr, volatile unsigned long *addr)
>{
> if (__builtin_constant_p(nr)) {
>  asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xorb %b1,%0"
>   : "+m" (*(volatile char *) ((void *)(addr) + ((nr)>>3)))
>   : "iq" ((1 << ((nr) & 7))));
> } else {
>  asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " " " "btcq" " " " %1,%0"
>   : : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_test_and_set_bit(long nr, volatile unsigned long *addr)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " " " "btsq" " " " %[val], " "%[var]" "\n\t/* output condition code " "c" "*/\n" : [var] "+m" (*addr), "=@cc" "c" (c) : [val] "Ir" (nr) : "memory"); c; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_test_and_set_bit_lock(long nr, volatile unsigned long *addr)
>{
> return arch_test_and_set_bit(nr, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch___test_and_set_bit(long nr, volatile unsigned long *addr)
>{
> bool oldbit;
>
> asm(" " "btsq" " " " %2,%1"
>     "\n\t/* output condition code " "c" "*/\n"
>     : "=@cc" "c" (oldbit)
>     : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
> return oldbit;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_test_and_clear_bit(long nr, volatile unsigned long *addr)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " " " "btrq" " " " %[val], " "%[var]" "\n\t/* output condition code " "c" "*/\n" : [var] "+m" (*addr), "=@cc" "c" (c) : [val] "Ir" (nr) : "memory"); c; });
>}
># 173 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch___test_and_clear_bit(long nr, volatile unsigned long *addr)
>{
> bool oldbit;
>
> asm volatile(" " "btrq" " " " %2,%1"
>       "\n\t/* output condition code " "c" "*/\n"
>       : "=@cc" "c" (oldbit)
>       : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
> return oldbit;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch___test_and_change_bit(long nr, volatile unsigned long *addr)
>{
> bool oldbit;
>
> asm volatile(" " "btcq" " " " %2,%1"
>       "\n\t/* output condition code " "c" "*/\n"
>       : "=@cc" "c" (oldbit)
>       : "m" (*(volatile long *) (addr)), "Ir" (nr) : "memory");
>
> return oldbit;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_test_and_change_bit(long nr, volatile unsigned long *addr)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " " " "btcq" " " " %[val], " "%[var]" "\n\t/* output condition code " "c" "*/\n" : [var] "+m" (*addr), "=@cc" "c" (c) : [val] "Ir" (nr) : "memory"); c; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool constant_test_bit(long nr, const volatile unsigned long *addr)
>{
> return ((1UL << (nr & (64 -1))) &
>  (addr[nr >> 6])) != 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool variable_test_bit(long nr, volatile const unsigned long *addr)
>{
> bool oldbit;
>
> asm volatile(" " "btq" " " " %2,%1"
>       "\n\t/* output condition code " "c" "*/\n"
>       : "=@cc" "c" (oldbit)
>       : "m" (*(unsigned long *)addr), "Ir" (nr) : "memory");
>
> return oldbit;
>}
># 233 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __ffs(unsigned long word)
>{
> asm("rep; bsf %1,%0"
>  : "=r" (word)
>  : "rm" (word));
> return word;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long ffz(unsigned long word)
>{
> asm("rep; bsf %1,%0"
>  : "=r" (word)
>  : "r" (~word));
> return word;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __fls(unsigned long word)
>{
> asm("bsr %1,%0"
>     : "=r" (word)
>     : "rm" (word));
> return word;
>}
># 283 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int ffs(int x)
>{
> int r;
># 297 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
> asm("bsfl %1,%0"
>     : "=r" (r)
>     : "rm" (x), "0" (-1));
># 310 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
> return r + 1;
>}
># 324 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int fls(unsigned int x)
>{
> int r;
># 338 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
> asm("bsrl %1,%0"
>     : "=r" (r)
>     : "rm" (x), "0" (-1));
># 351 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
> return r + 1;
>}
># 366 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int fls64(__u64 x)
>{
> int bitpos = -1;
>
>
>
>
>
> asm("bsrq %1,%q0"
>     : "+r" (bitpos)
>     : "rm" (x));
> return bitpos + 1;
>}
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h" 1
>
>
>
>
>extern unsigned long _find_next_bit(const unsigned long *addr1,
>  const unsigned long *addr2, unsigned long nbits,
>  unsigned long start, unsigned long invert, unsigned long le);
>extern unsigned long _find_first_bit(const unsigned long *addr, unsigned long size);
>extern unsigned long _find_first_zero_bit(const unsigned long *addr, unsigned long size);
>extern unsigned long _find_last_bit(const unsigned long *addr, unsigned long size);
># 22 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long find_next_bit(const unsigned long *addr, unsigned long size,
>       unsigned long offset)
>{
> if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {
>  unsigned long val;
>
>  if (__builtin_expect(!!(offset >= size), 0))
>   return size;
>
>  val = *addr & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((offset) > (size - 1)) * 0l)) : (int *)8))), (offset) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (offset)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));
>  return val ? __ffs(val) : size;
> }
>
> return _find_next_bit(addr, ((void *)0), size, offset, 0UL, 0);
>}
># 51 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long find_next_and_bit(const unsigned long *addr1,
>  const unsigned long *addr2, unsigned long size,
>  unsigned long offset)
>{
> if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {
>  unsigned long val;
>
>  if (__builtin_expect(!!(offset >= size), 0))
>   return size;
>
>  val = *addr1 & *addr2 & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((offset) > (size - 1)) * 0l)) : (int *)8))), (offset) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (offset)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));
>  return val ? __ffs(val) : size;
> }
>
> return _find_next_bit(addr1, addr2, size, offset, 0UL, 0);
>}
># 80 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long find_next_zero_bit(const unsigned long *addr, unsigned long size,
>     unsigned long offset)
>{
> if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {
>  unsigned long val;
>
>  if (__builtin_expect(!!(offset >= size), 0))
>   return size;
>
>  val = *addr | ~((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((offset) > (size - 1)) * 0l)) : (int *)8))), (offset) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (offset)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));
>  return val == ~0UL ? size : ffz(val);
> }
>
> return _find_next_bit(addr, ((void *)0), size, offset, ~0UL, 0);
>}
># 109 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long find_first_bit(const unsigned long *addr, unsigned long size)
>{
> if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {
>  unsigned long val = *addr & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));
>
>  return val ? __ffs(val) : size;
> }
>
> return _find_first_bit(addr, size);
>}
># 131 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long find_first_zero_bit(const unsigned long *addr, unsigned long size)
>{
> if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {
>  unsigned long val = *addr | ~((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));
>
>  return val == ~0UL ? size : ffz(val);
> }
>
> return _find_first_zero_bit(addr, size);
>}
># 163 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long find_last_bit(const unsigned long *addr, unsigned long size)
>{
> if ((__builtin_constant_p(size) && (size) <= 64 && (size) > 0)) {
>  unsigned long val = *addr & ((((int)(sizeof(struct { int:(-!!(__builtin_choose_expr( (sizeof(int) == sizeof(*(8 ? ((void *)((long)((0) > (size - 1)) * 0l)) : (int *)8))), (0) > (size - 1), 0))); })))) + (((~(((0UL)))) - ((((1UL))) << (0)) + 1) & (~(((0UL))) >> (64 - 1 - (size - 1)))));
>
>  return val ? __fls(val) : size;
> }
>
> return _find_last_bit(addr, size);
>}
># 186 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/find.h"
>extern unsigned long find_next_clump8(unsigned long *clump,
>          const unsigned long *addr,
>          unsigned long size, unsigned long offset);
># 384 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/sched.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/sched.h" 2
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sched_find_first_bit(const unsigned long *b)
>{
>
> if (b[0])
>  return __ffs(b[0]);
> return __ffs(b[1]) + 64;
># 30 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/sched.h"
>}
># 386 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/arch_hweight.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeatures.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/required-features.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeatures.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/disabled-features.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeatures.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/arch_hweight.h" 2
># 15 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/arch_hweight.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned int __arch_hweight32(unsigned int w)
>{
> unsigned int res;
>
> asm ("# ALT: oldnstr\n" "661:\n\t" "call __sw_hweight32" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 4*32+23)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "popcntl %1, %0" "\n" "665""1" ":\n" ".popsection\n"
>    : "=""a" (res)
>    : "D" (w));
>
> return res;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __arch_hweight16(unsigned int w)
>{
> return __arch_hweight32(w & 0xffff);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __arch_hweight8(unsigned int w)
>{
> return __arch_hweight32(w & 0xff);
>}
># 43 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/arch_hweight.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __arch_hweight64(__u64 w)
>{
> unsigned long res;
>
> asm ("# ALT: oldnstr\n" "661:\n\t" "call __sw_hweight64" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 4*32+23)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "popcntq %1, %0" "\n" "665""1" ":\n" ".popsection\n"
>    : "=""a" (res)
>    : "D" (w));
>
> return res;
>}
># 388 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/const_hweight.h" 1
># 390 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void instrument_read(const volatile void *v, size_t size)
>{
> kasan_check_read(v, size);
> kcsan_check_access(v, size, 0);
>}
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void instrument_write(const volatile void *v, size_t size)
>{
> kasan_check_write(v, size);
> kcsan_check_access(v, size, (1 << 0));
>}
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void instrument_read_write(const volatile void *v, size_t size)
>{
> kasan_check_write(v, size);
> kcsan_check_access(v, size, (1 << 1) | (1 << 0));
>}
># 69 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void instrument_atomic_read(const volatile void *v, size_t size)
>{
> kasan_check_read(v, size);
> kcsan_check_access(v, size, (1 << 2));
>}
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void instrument_atomic_write(const volatile void *v, size_t size)
>{
> kasan_check_write(v, size);
> kcsan_check_access(v, size, (1 << 2) | (1 << 0));
>}
># 99 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void instrument_atomic_read_write(const volatile void *v, size_t size)
>{
> kasan_check_write(v, size);
> kcsan_check_access(v, size, (1 << 2) | (1 << 0) | (1 << 1));
>}
># 115 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>instrument_copy_to_user(void *to, const void *from, unsigned long n)
>{
> kasan_check_read(from, n);
> kcsan_check_access(from, n, 0);
>}
># 132 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>instrument_copy_from_user(const void *to, const void *from, unsigned long n)
>{
> kasan_check_write(to, n);
> kcsan_check_access(to, n, (1 << 0));
>}
># 15 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h" 2
># 26 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_bit(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_write(addr + ((nr) / 64), sizeof(long));
> arch_set_bit(nr, addr);
>}
># 39 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_bit(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_write(addr + ((nr) / 64), sizeof(long));
> arch_clear_bit(nr, addr);
>}
># 55 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void change_bit(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_write(addr + ((nr) / 64), sizeof(long));
> arch_change_bit(nr, addr);
>}
># 68 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_and_set_bit(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_read_write(addr + ((nr) / 64), sizeof(long));
> return arch_test_and_set_bit(nr, addr);
>}
># 81 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_and_clear_bit(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_read_write(addr + ((nr) / 64), sizeof(long));
> return arch_test_and_clear_bit(nr, addr);
>}
># 94 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_and_change_bit(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_read_write(addr + ((nr) / 64), sizeof(long));
> return arch_test_and_change_bit(nr, addr);
>}
># 392 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __set_bit(long nr, volatile unsigned long *addr)
>{
> if (!0)
>  instrument_write(addr + ((nr) / 64), sizeof(long));
> arch___set_bit(nr, addr);
>}
># 41 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __clear_bit(long nr, volatile unsigned long *addr)
>{
> if (!0)
>  instrument_write(addr + ((nr) / 64), sizeof(long));
> arch___clear_bit(nr, addr);
>}
># 57 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __change_bit(long nr, volatile unsigned long *addr)
>{
> if (!0)
>  instrument_write(addr + ((nr) / 64), sizeof(long));
> arch___change_bit(nr, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __instrument_read_write_bitop(long nr, volatile unsigned long *addr)
>{
> if (0) {
># 77 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>  kcsan_check_access(addr + ((nr) / 64), sizeof(long), 0);
>
>
>
>
>  instrument_write(addr + ((nr) / 64), sizeof(long));
> } else {
>  instrument_read_write(addr + ((nr) / 64), sizeof(long));
> }
>}
># 96 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __test_and_set_bit(long nr, volatile unsigned long *addr)
>{
> if (!0)
>  __instrument_read_write_bitop(nr, addr);
> return arch___test_and_set_bit(nr, addr);
>}
># 111 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __test_and_clear_bit(long nr, volatile unsigned long *addr)
>{
> if (!0)
>  __instrument_read_write_bitop(nr, addr);
> return arch___test_and_clear_bit(nr, addr);
>}
># 126 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-non-atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __test_and_change_bit(long nr, volatile unsigned long *addr)
>{
> if (!0)
>  __instrument_read_write_bitop(nr, addr);
> return arch___test_and_change_bit(nr, addr);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_bit(long nr, const volatile unsigned long *addr)
>{
> if (!0)
>  instrument_atomic_read(addr + ((nr) / 64), sizeof(long));
> return (__builtin_constant_p((nr)) ? constant_test_bit((nr), (addr)) : variable_test_bit((nr), (addr)));
>}
># 393 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-lock.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-lock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_bit_unlock(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_write(addr + ((nr) / 64), sizeof(long));
> arch_clear_bit_unlock(nr, addr);
>}
># 38 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-lock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __clear_bit_unlock(long nr, volatile unsigned long *addr)
>{
> instrument_write(addr + ((nr) / 64), sizeof(long));
> arch___clear_bit_unlock(nr, addr);
>}
># 53 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-lock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_and_set_bit_lock(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_read_write(addr + ((nr) / 64), sizeof(long));
> return arch_test_and_set_bit_lock(nr, addr);
>}
># 71 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/instrumented-lock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>clear_bit_unlock_is_negative_byte(long nr, volatile unsigned long *addr)
>{
> instrument_atomic_write(addr + ((nr) / 64), sizeof(long));
> return arch_clear_bit_unlock_is_negative_byte(nr, addr);
>}
># 394 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/le.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/le.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/byteorder.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/byteorder/little_endian.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/byteorder/little_endian.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/byteorder/little_endian.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/swab.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/swab.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/swab.h" 1
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __arch_swab32(__u32 val)
>{
> asm("bswapl %0" : "=r" (val) : "0" (val));
> return val;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u64 __arch_swab64(__u64 val)
>{
># 31 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/swab.h"
> asm("bswapq %0" : "=r" (val) : "0" (val));
> return val;
>
>}
># 9 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/swab.h" 2
># 48 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/swab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u16 __fswab16(__u16 val)
>{
>
>
>
> return ((__u16)( (((__u16)(val) & (__u16)0x00ffU) << 8) | (((__u16)(val) & (__u16)0xff00U) >> 8)));
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __fswab32(__u32 val)
>{
>
> return __arch_swab32(val);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u64 __fswab64(__u64 val)
>{
>
> return __arch_swab64(val);
>
>
>
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __fswahw32(__u32 val)
>{
>
>
>
> return ((__u32)( (((__u32)(val) & (__u32)0x0000ffffUL) << 16) | (((__u32)(val) & (__u32)0xffff0000UL) >> 16)));
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__)) __u32 __fswahb32(__u32 val)
>{
>
>
>
> return ((__u32)( (((__u32)(val) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(val) & (__u32)0xff00ff00UL) >> 8)));
>
>}
># 136 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/swab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __swab(const unsigned long y)
>{
>
> return (__u64)__builtin_bswap64((__u64)(y));
>
>
>
>}
># 171 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/swab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u16 __swab16p(const __u16 *p)
>{
>
>
>
> return (__u16)__builtin_bswap16((__u16)(*p));
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u32 __swab32p(const __u32 *p)
>{
>
>
>
> return (__u32)__builtin_bswap32((__u32)(*p));
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u64 __swab64p(const __u64 *p)
>{
>
>
>
> return (__u64)__builtin_bswap64((__u64)(*p));
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u32 __swahw32p(const __u32 *p)
>{
>
>
>
> return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x0000ffffUL) << 16) | (((__u32)(*p) & (__u32)0xffff0000UL) >> 16))) : __fswahw32(*p));
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u32 __swahb32p(const __u32 *p)
>{
>
>
>
> return (__builtin_constant_p((__u32)(*p)) ? ((__u32)( (((__u32)(*p) & (__u32)0x00ff00ffUL) << 8) | (((__u32)(*p) & (__u32)0xff00ff00UL) >> 8))) : __fswahb32(*p));
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __swab16s(__u16 *p)
>{
>
>
>
> *p = __swab16p(p);
>
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __swab32s(__u32 *p)
>{
>
>
>
> *p = __swab32p(p);
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __swab64s(__u64 *p)
>{
>
>
>
> *p = __swab64p(p);
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __swahw32s(__u32 *p)
>{
>
>
>
> *p = __swahw32p(p);
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __swahb32s(__u32 *p)
>{
>
>
>
> *p = __swahb32p(p);
>
>}
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/swab.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/swab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void swab16_array(u16 *buf, unsigned int words)
>{
> while (words--) {
>  __swab16s(buf);
>  buf++;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void swab32_array(u32 *buf, unsigned int words)
>{
> while (words--) {
>  __swab32s(buf);
>  buf++;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void swab64_array(u64 *buf, unsigned int words)
>{
> while (words--) {
>  __swab64s(buf);
>  buf++;
> }
>}
># 15 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/byteorder/little_endian.h" 2
># 45 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/byteorder/little_endian.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __le64 __cpu_to_le64p(const __u64 *p)
>{
> return ( __le64)*p;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u64 __le64_to_cpup(const __le64 *p)
>{
> return ( __u64)*p;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __le32 __cpu_to_le32p(const __u32 *p)
>{
> return ( __le32)*p;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u32 __le32_to_cpup(const __le32 *p)
>{
> return ( __u32)*p;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __le16 __cpu_to_le16p(const __u16 *p)
>{
> return ( __le16)*p;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u16 __le16_to_cpup(const __le16 *p)
>{
> return ( __u16)*p;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __be64 __cpu_to_be64p(const __u64 *p)
>{
> return ( __be64)__swab64p(p);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u64 __be64_to_cpup(const __be64 *p)
>{
> return __swab64p((__u64 *)p);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __be32 __cpu_to_be32p(const __u32 *p)
>{
> return ( __be32)__swab32p(p);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u32 __be32_to_cpup(const __be32 *p)
>{
> return __swab32p((__u32 *)p);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __be16 __cpu_to_be16p(const __u16 *p)
>{
> return ( __be16)__swab16p(p);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __u16 __be16_to_cpup(const __be16 *p)
>{
> return __swab16p((__u16 *)p);
>}
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/byteorder/little_endian.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/byteorder/generic.h" 1
># 144 "/usr/src/linux-5.14.21-150500.53/include/linux/byteorder/generic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void le16_add_cpu(__le16 *var, u16 val)
>{
> *var = (( __le16)(__u16)((( __u16)(__le16)(*var)) + val));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void le32_add_cpu(__le32 *var, u32 val)
>{
> *var = (( __le32)(__u32)((( __u32)(__le32)(*var)) + val));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void le64_add_cpu(__le64 *var, u64 val)
>{
> *var = (( __le64)(__u64)((( __u64)(__le64)(*var)) + val));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void le32_to_cpu_array(u32 *buf, unsigned int words)
>{
> while (words--) {
>  do { (void)(buf); } while (0);
>  buf++;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpu_to_le32_array(u32 *buf, unsigned int words)
>{
> while (words--) {
>  do { (void)(buf); } while (0);
>  buf++;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void be16_add_cpu(__be16 *var, u16 val)
>{
> *var = (( __be16)(__u16)__builtin_bswap16((__u16)(((__u16)__builtin_bswap16((__u16)(( __u16)(__be16)(*var))) + val))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void be32_add_cpu(__be32 *var, u32 val)
>{
> *var = (( __be32)(__u32)__builtin_bswap32((__u32)(((__u32)__builtin_bswap32((__u32)(( __u32)(__be32)(*var))) + val))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void be64_add_cpu(__be64 *var, u64 val)
>{
> *var = (( __be64)(__u64)__builtin_bswap64((__u64)(((__u64)__builtin_bswap64((__u64)(( __u64)(__be64)(*var))) + val))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpu_to_be32_array(__be32 *dst, const u32 *src, size_t len)
>{
> int i;
>
> for (i = 0; i < len; i++)
>  dst[i] = (( __be32)(__u32)__builtin_bswap32((__u32)((src[i]))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void be32_to_cpu_array(u32 *dst, const __be32 *src, size_t len)
>{
> int i;
>
> for (i = 0; i < len; i++)
>  dst[i] = (__u32)__builtin_bswap32((__u32)(( __u32)(__be32)(src[i])));
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/byteorder/little_endian.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/byteorder.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/le.h" 2
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long find_next_zero_bit_le(const void *addr,
>  unsigned long size, unsigned long offset)
>{
> return find_next_zero_bit(addr, size, offset);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long find_next_bit_le(const void *addr,
>  unsigned long size, unsigned long offset)
>{
> return find_next_bit(addr, size, offset);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long find_first_zero_bit_le(const void *addr,
>  unsigned long size)
>{
> return find_first_zero_bit(addr, size);
>}
># 83 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/le.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_bit_le(int nr, const void *addr)
>{
> return test_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_bit_le(int nr, void *addr)
>{
> set_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_bit_le(int nr, void *addr)
>{
> clear_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __set_bit_le(int nr, void *addr)
>{
> __set_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __clear_bit_le(int nr, void *addr)
>{
> __clear_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_and_set_bit_le(int nr, void *addr)
>{
> return test_and_set_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_and_clear_bit_le(int nr, void *addr)
>{
> return test_and_clear_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __test_and_set_bit_le(int nr, void *addr)
>{
> return __test_and_set_bit(nr ^ 0, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __test_and_clear_bit_le(int nr, void *addr)
>{
> return __test_and_clear_bit(nr ^ 0, addr);
>}
># 396 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bitops/ext2-atomic-setbit.h" 1
># 398 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bitops.h" 2
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h" 2
># 69 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_bitmask_order(unsigned int count)
>{
> int order;
>
> order = fls(count);
> return order;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long hweight_long(unsigned long w)
>{
> return sizeof(w) == 4 ? (__builtin_constant_p(w) ? ((((unsigned int) ((!!((w) & (1ULL << 0))) + (!!((w) & (1ULL << 1))) + (!!((w) & (1ULL << 2))) + (!!((w) & (1ULL << 3))) + (!!((w) & (1ULL << 4))) + (!!((w) & (1ULL << 5))) + (!!((w) & (1ULL << 6))) + (!!((w) & (1ULL << 7))))) + ((unsigned int) ((!!(((w) >> 8) & (1ULL << 0))) + (!!(((w) >> 8) & (1ULL << 1))) + (!!(((w) >> 8) & (1ULL << 2))) + (!!(((w) >> 8) & (1ULL << 3))) + (!!(((w) >> 8) & (1ULL << 4))) + (!!(((w) >> 8) & (1ULL << 5))) + (!!(((w) >> 8) & (1ULL << 6))) + (!!(((w) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!(((w) >> 16) & (1ULL << 0))) + (!!(((w) >> 16) & (1ULL << 1))) + (!!(((w) >> 16) & (1ULL << 2))) + (!!(((w) >> 16) & (1ULL << 3))) + (!!(((w) >> 16) & (1ULL << 4))) + (!!(((w) >> 16) & (1ULL << 5))) + (!!(((w) >> 16) & (1ULL << 6))) + (!!(((w) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!((((w) >> 16) >> 8) & (1ULL << 0))) + (!!((((w) >> 16) >> 8) & (1ULL << 1))) + (!!((((w) >> 16) >> 8) & (1ULL << 2))) + (!!((((w) >> 16) >> 8) & (1ULL << 3))) + (!!((((w) >> 16) >> 8) & (1ULL << 4))) + (!!((((w) >> 16) >> 8) & (1ULL << 5))) + (!!((((w) >> 16) >> 8) & (1ULL << 6))) + (!!((((w) >> 16) >> 8) & (1ULL << 7))))))) : __arch_hweight32(w)) : (__builtin_constant_p((__u64)w) ? (((((unsigned int) ((!!(((__u64)w) & (1ULL << 0))) + (!!(((__u64)w) & (1ULL << 1))) + (!!(((__u64)w) & (1ULL << 2))) + (!!(((__u64)w) & (1ULL << 3))) + (!!(((__u64)w) & (1ULL << 4))) + (!!(((__u64)w) & (1ULL << 5))) + (!!(((__u64)w) & (1ULL << 6))) + (!!(((__u64)w) & (1ULL << 7))))) + ((unsigned int) ((!!((((__u64)w) >> 8) & (1ULL << 0))) + (!!((((__u64)w) >> 8) & (1ULL << 1))) + (!!((((__u64)w) >> 8) & (1ULL << 2))) + (!!((((__u64)w) >> 8) & (1ULL << 3))) + (!!((((__u64)w) >> 8) & (1ULL << 4))) + (!!((((__u64)w) >> 8) & (1ULL << 5))) + (!!((((__u64)w) >> 8) & (1ULL << 6))) + (!!((((__u64)w) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!((((__u64)w) >> 16) & (1ULL << 0))) + (!!((((__u64)w) >> 16) & (1ULL << 1))) + (!!((((__u64)w) >> 16) & (1ULL << 2))) + (!!((((__u64)w) >> 16) & (1ULL << 3))) + (!!((((__u64)w) >> 16) & (1ULL << 4))) + (!!((((__u64)w) >> 16) & (1ULL << 5))) + (!!((((__u64)w) >> 16) & (1ULL << 6))) + (!!((((__u64)w) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!(((((__u64)w) >> 16) >> 8) & (1ULL << 0))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 1))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 2))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 3))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 4))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 5))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 6))) + (!!(((((__u64)w) >> 16) >> 8) & (1ULL << 7))))))) + ((((unsigned int) ((!!((((__u64)w) >> 32) & (1ULL << 0))) + (!!((((__u64)w) >> 32) & (1ULL << 1))) + (!!((((__u64)w) >> 32) & (1ULL << 2))) + (!!((((__u64)w) >> 32) & (1ULL << 3))) + (!!((((__u64)w) >> 32) & (1ULL << 4))) + (!!((((__u64)w) >> 32) & (1ULL << 5))) + (!!((((__u64)w) >> 32) & (1ULL << 6))) + (!!((((__u64)w) >> 32) & (1ULL << 7))))) + ((unsigned int) ((!!(((((__u64)w) >> 32) >> 8) & (1ULL << 0))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 1))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 2))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 3))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 4))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 5))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 6))) + (!!(((((__u64)w) >> 32) >> 8) & (1ULL << 7)))))) + (((unsigned int) ((!!(((((__u64)w) >> 32) >> 16) & (1ULL << 0))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 1))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 2))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 3))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 4))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 5))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 6))) + (!!(((((__u64)w) >> 32) >> 16) & (1ULL << 7))))) + ((unsigned int) ((!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 0))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 1))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 2))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 3))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 4))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 5))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 6))) + (!!((((((__u64)w) >> 32) >> 16) >> 8) & (1ULL << 7)))))))) : __arch_hweight64((__u64)w));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u64 rol64(__u64 word, unsigned int shift)
>{
> return (word << (shift & 63)) | (word >> ((-shift) & 63));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u64 ror64(__u64 word, unsigned int shift)
>{
> return (word >> (shift & 63)) | (word << ((-shift) & 63));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u32 rol32(__u32 word, unsigned int shift)
>{
> return (word << (shift & 31)) | (word >> ((-shift) & 31));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u32 ror32(__u32 word, unsigned int shift)
>{
> return (word >> (shift & 31)) | (word << ((-shift) & 31));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u16 rol16(__u16 word, unsigned int shift)
>{
> return (word << (shift & 15)) | (word >> ((-shift) & 15));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u16 ror16(__u16 word, unsigned int shift)
>{
> return (word >> (shift & 15)) | (word << ((-shift) & 15));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u8 rol8(__u8 word, unsigned int shift)
>{
> return (word << (shift & 7)) | (word >> ((-shift) & 7));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u8 ror8(__u8 word, unsigned int shift)
>{
> return (word >> (shift & 7)) | (word << ((-shift) & 7));
>}
># 169 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __s32 sign_extend32(__u32 value, int index)
>{
> __u8 shift = 31 - index;
> return (__s32)(value << shift) >> shift;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __s64 sign_extend64(__u64 value, int index)
>{
> __u8 shift = 63 - index;
> return (__s64)(value << shift) >> shift;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned fls_long(unsigned long l)
>{
> if (sizeof(l) == 4)
>  return fls(l);
> return fls64(l);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_count_order(unsigned int count)
>{
> if (count == 0)
>  return -1;
>
> return fls(--count);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_count_order_long(unsigned long l)
>{
> if (l == 0UL)
>  return -1;
> return (int)fls_long(--l);
>}
># 222 "/usr/src/linux-5.14.21-150500.53/include/linux/bitops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __ffs64(u64 word)
>{
>
>
>
>
>
>
> return __ffs((unsigned long)word);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void assign_bit(long nr, volatile unsigned long *addr,
>           bool value)
>{
> if (value)
>  set_bit(nr, addr);
> else
>  clear_bit(nr, addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __assign_bit(long nr, volatile unsigned long *addr,
>      bool value)
>{
> if (value)
>  __set_bit(nr, addr);
> else
>  __clear_bit(nr, addr);
>}
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kstrtox.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/kstrtox.h"
>int __attribute__((__warn_unused_result__)) _kstrtoul(const char *s, unsigned int base, unsigned long *res);
>int __attribute__((__warn_unused_result__)) _kstrtol(const char *s, unsigned int base, long *res);
>
>int __attribute__((__warn_unused_result__)) kstrtoull(const char *s, unsigned int base, unsigned long long *res);
>int __attribute__((__warn_unused_result__)) kstrtoll(const char *s, unsigned int base, long long *res);
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/kstrtox.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtoul(const char *s, unsigned int base, unsigned long *res)
>{
>
>
>
>
> if (sizeof(unsigned long) == sizeof(unsigned long long) &&
>     __alignof__(unsigned long) == __alignof__(unsigned long long))
>  return kstrtoull(s, base, (unsigned long long *)res);
> else
>  return _kstrtoul(s, base, res);
>}
># 58 "/usr/src/linux-5.14.21-150500.53/include/linux/kstrtox.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtol(const char *s, unsigned int base, long *res)
>{
>
>
>
>
> if (sizeof(long) == sizeof(long long) &&
>     __alignof__(long) == __alignof__(long long))
>  return kstrtoll(s, base, (long long *)res);
> else
>  return _kstrtol(s, base, res);
>}
>
>int __attribute__((__warn_unused_result__)) kstrtouint(const char *s, unsigned int base, unsigned int *res);
>int __attribute__((__warn_unused_result__)) kstrtoint(const char *s, unsigned int base, int *res);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtou64(const char *s, unsigned int base, u64 *res)
>{
> return kstrtoull(s, base, res);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtos64(const char *s, unsigned int base, s64 *res)
>{
> return kstrtoll(s, base, res);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtou32(const char *s, unsigned int base, u32 *res)
>{
> return kstrtouint(s, base, res);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtos32(const char *s, unsigned int base, s32 *res)
>{
> return kstrtoint(s, base, res);
>}
>
>int __attribute__((__warn_unused_result__)) kstrtou16(const char *s, unsigned int base, u16 *res);
>int __attribute__((__warn_unused_result__)) kstrtos16(const char *s, unsigned int base, s16 *res);
>int __attribute__((__warn_unused_result__)) kstrtou8(const char *s, unsigned int base, u8 *res);
>int __attribute__((__warn_unused_result__)) kstrtos8(const char *s, unsigned int base, s8 *res);
>int __attribute__((__warn_unused_result__)) kstrtobool(const char *s, bool *res);
>
>int __attribute__((__warn_unused_result__)) kstrtoull_from_user(const char *s, size_t count, unsigned int base, unsigned long long *res);
>int __attribute__((__warn_unused_result__)) kstrtoll_from_user(const char *s, size_t count, unsigned int base, long long *res);
>int __attribute__((__warn_unused_result__)) kstrtoul_from_user(const char *s, size_t count, unsigned int base, unsigned long *res);
>int __attribute__((__warn_unused_result__)) kstrtol_from_user(const char *s, size_t count, unsigned int base, long *res);
>int __attribute__((__warn_unused_result__)) kstrtouint_from_user(const char *s, size_t count, unsigned int base, unsigned int *res);
>int __attribute__((__warn_unused_result__)) kstrtoint_from_user(const char *s, size_t count, unsigned int base, int *res);
>int __attribute__((__warn_unused_result__)) kstrtou16_from_user(const char *s, size_t count, unsigned int base, u16 *res);
>int __attribute__((__warn_unused_result__)) kstrtos16_from_user(const char *s, size_t count, unsigned int base, s16 *res);
>int __attribute__((__warn_unused_result__)) kstrtou8_from_user(const char *s, size_t count, unsigned int base, u8 *res);
>int __attribute__((__warn_unused_result__)) kstrtos8_from_user(const char *s, size_t count, unsigned int base, s8 *res);
>int __attribute__((__warn_unused_result__)) kstrtobool_from_user(const char *s, size_t count, bool *res);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtou64_from_user(const char *s, size_t count, unsigned int base, u64 *res)
>{
> return kstrtoull_from_user(s, count, base, res);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtos64_from_user(const char *s, size_t count, unsigned int base, s64 *res)
>{
> return kstrtoll_from_user(s, count, base, res);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtou32_from_user(const char *s, size_t count, unsigned int base, u32 *res)
>{
> return kstrtouint_from_user(s, count, base, res);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kstrtos32_from_user(const char *s, size_t count, unsigned int base, s32 *res)
>{
> return kstrtoint_from_user(s, count, base, res);
>}
># 145 "/usr/src/linux-5.14.21-150500.53/include/linux/kstrtox.h"
>extern unsigned long simple_strtoul(const char *,char **,unsigned int);
>extern long simple_strtol(const char *,char **,unsigned int);
>extern unsigned long long simple_strtoull(const char *,char **,unsigned int);
>extern long long simple_strtoll(const char *,char **,unsigned int);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int strtobool(const char *s, bool *res)
>{
> return kstrtobool(s, res);
>}
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/log2.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/log2.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((const))
>int __ilog2_u32(u32 n)
>{
> return fls(n) - 1;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((const))
>int __ilog2_u64(u64 n)
>{
> return fls64(n) - 1;
>}
># 44 "/usr/src/linux-5.14.21-150500.53/include/linux/log2.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((const))
>bool is_power_of_2(unsigned long n)
>{
> return (n != 0 && ((n & (n - 1)) == 0));
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((const))
>unsigned long __roundup_pow_of_two(unsigned long n)
>{
> return 1UL << fls_long(n - 1);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((const))
>unsigned long __rounddown_pow_of_two(unsigned long n)
>{
> return 1UL << (fls_long(n) - 1);
>}
># 198 "/usr/src/linux-5.14.21-150500.53/include/linux/log2.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__const__))
>int __order_base_2(unsigned long n)
>{
> return n > 1 ? ( __builtin_constant_p(n - 1) ? ((n - 1) < 2 ? 0 : 63 - __builtin_clzll(n - 1)) : (sizeof(n - 1) <= 4) ? __ilog2_u32(n - 1) : __ilog2_u64(n - 1) ) + 1 : 0;
>}
># 225 "/usr/src/linux-5.14.21-150500.53/include/linux/log2.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((const))
>int __bits_per(unsigned long n)
>{
> if (n < 2)
>  return 1;
> if (is_power_of_2(n))
>  return ( __builtin_constant_p(n) ? ( ((n) == 0 || (n) == 1) ? 0 : ( __builtin_constant_p((n) - 1) ? (((n) - 1) < 2 ? 0 : 63 - __builtin_clzll((n) - 1)) : (sizeof((n) - 1) <= 4) ? __ilog2_u32((n) - 1) : __ilog2_u64((n) - 1) ) + 1) : __order_base_2(n) ) + 1;
> return ( __builtin_constant_p(n) ? ( ((n) == 0 || (n) == 1) ? 0 : ( __builtin_constant_p((n) - 1) ? (((n) - 1) < 2 ? 0 : 63 - __builtin_clzll((n) - 1)) : (sizeof((n) - 1) <= 4) ? __ilog2_u32((n) - 1) : __ilog2_u64((n) - 1) ) + 1) : __order_base_2(n) );
>}
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/math.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/div64.h" 1
># 75 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/div64.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/div64.h" 1
># 76 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/div64.h" 2
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 mul_u64_u64_div_u64(u64 a, u64 mul, u64 div)
>{
> u64 q;
>
> asm ("mulq %2; divq %3" : "=a" (q)
>    : "a" (a), "rm" (mul), "rm" (div)
>    : "rdx");
>
> return q;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 mul_u64_u32_div(u64 a, u32 mul, u32 div)
>{
> return mul_u64_u64_div_u64(a, mul, div);
>}
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/math.h" 2
># 160 "/usr/src/linux-5.14.21-150500.53/include/linux/math.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 reciprocal_scale(u32 val, u32 ep_ro)
>{
> return (u32)(((u64) val * ep_ro) >> 32);
>}
>
>u64 int_pow(u64 base, unsigned int exp);
>unsigned long int_sqrt(unsigned long);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 int_sqrt64(u64 x)
>{
> return (u32)int_sqrt(x);
>}
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/minmax.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/panic.h" 1
>
>
>
>
>
>
>
>struct pt_regs;
>
>extern long (*panic_blink)(int state);
>__attribute__((__format__(printf, 1, 2)))
>void panic(const char *fmt, ...) __attribute__((__noreturn__)) __attribute__((__cold__));
>void nmi_panic(struct pt_regs *regs, const char *msg);
>extern void oops_enter(void);
>extern void oops_exit(void);
>extern bool oops_may_print(void);
>
>
>extern unsigned int sysctl_oops_all_cpu_backtrace;
>
>
>
>
>extern int panic_timeout;
>extern unsigned long panic_print;
>extern int panic_on_oops;
>extern int panic_on_unrecovered_nmi;
>extern int panic_on_io_nmi;
>extern int panic_on_warn;
>
>extern unsigned long panic_on_taint;
>extern bool panic_on_taint_nousertaint;
>
>extern int sysctl_panic_on_rcu_stall;
>extern int sysctl_max_rcu_stall_to_panic;
>extern int sysctl_panic_on_stackoverflow;
>
>extern bool crash_kexec_post_notifiers;
>
>
>extern int suse_unsupported;
>
>
>
>
>
>
>
>extern atomic_t panic_cpu;
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_arch_panic_timeout(int timeout, int arch_default_timeout)
>{
> if (panic_timeout == arch_default_timeout)
>  panic_timeout = timeout;
>}
># 99 "/usr/src/linux-5.14.21-150500.53/include/linux/panic.h"
>struct taint_flag {
> char c_true;
> char c_false;
> bool module;
>};
>
>extern const struct taint_flag taint_flags[32];
>
>enum lockdep_ok {
> LOCKDEP_STILL_OK,
> LOCKDEP_NOW_UNRELIABLE,
>};
>
>extern const char *print_tainted(void);
>extern void add_taint(unsigned flag, enum lockdep_ok);
>extern int test_taint(unsigned flag);
>extern unsigned long get_taint(void);
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/init.h" 1
># 116 "/usr/src/linux-5.14.21-150500.53/include/linux/init.h"
>typedef int (*initcall_t)(void);
>typedef void (*exitcall_t)(void);
>
>
>typedef int initcall_entry_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) initcall_t initcall_from_entry(initcall_entry_t *entry)
>{
> return offset_to_ptr(entry);
>}
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/init.h"
>extern initcall_entry_t __con_initcall_start[], __con_initcall_end[];
>
>
>typedef void (*ctor_fn_t)(void);
>
>struct file_system_type;
>
>
>extern int do_one_initcall(initcall_t fn);
>extern char __attribute__((__section__(".init.data"))) boot_command_line[];
>extern char *saved_command_line;
>extern unsigned int reset_devices;
>
>
>void setup_arch(char **);
>void prepare_namespace(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) init_rootfs(void);
>extern struct file_system_type rootfs_fs_type;
>
>
>extern bool rodata_enabled;
>
>
>void mark_rodata_ro(void);
>
>
>extern void (*late_time_init)(void);
>
>extern bool initcall_debug;
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kern_levels.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cache.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cache.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/cache.h" 2
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ratelimit_types.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/param.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/param.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/param.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/param.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/param.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/param.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/param.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/ratelimit_types.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types_raw.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock_types.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qspinlock_types.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qspinlock_types.h"
>typedef struct qspinlock {
> union {
>  atomic_t val;
>
>
>
>
>
>
>
>  struct {
>   u8 locked;
>   u8 pending;
>  };
>  struct {
>   u16 locked_pending;
>   u16 tail;
>  };
># 43 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qspinlock_types.h"
> };
>} arch_spinlock_t;
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock_types.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qrwlock_types.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock_types.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qrwlock_types.h" 2
>
>
>
>
>
>typedef struct qrwlock {
> union {
>  atomic_t cnts;
>  struct {
>
>   u8 wlocked;
>   u8 __lstate[3];
>
>
>
>
>  };
> };
> arch_spinlock_t wait_lock;
>} arch_rwlock_t;
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock_types.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types_raw.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep_types.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep_types.h"
>enum lockdep_wait_type {
> LD_WAIT_INV = 0,
>
> LD_WAIT_FREE,
> LD_WAIT_SPIN,
>
>
>
>
> LD_WAIT_CONFIG = LD_WAIT_SPIN,
>
> LD_WAIT_SLEEP,
>
> LD_WAIT_MAX,
>};
>
>enum lockdep_lock_type {
> LD_LOCK_NORMAL = 0,
> LD_LOCK_PERCPU,
> LD_LOCK_MAX,
>};
># 197 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep_types.h"
>struct lock_class_key { };
>
>
>
>
>struct lockdep_map { };
>
>struct pin_cookie { };
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types_raw.h" 2
>
>typedef struct raw_spinlock {
> arch_spinlock_t raw_lock;
>
>
>
>
>
>
>
>} raw_spinlock_t;
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types.h" 2
>
>
>
>
>typedef struct spinlock {
> union {
>  struct raw_spinlock rlock;
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types.h"
> };
>} spinlock_t;
># 74 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock_types.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock_types.h"
>typedef struct {
> arch_rwlock_t raw_lock;
>
>
>
>
>
>
>
>} rwlock_t;
># 75 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_types.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/ratelimit_types.h" 2
>
>
>
>
>
>
>
>struct ratelimit_state {
> raw_spinlock_t lock;
>
> int interval;
> int burst;
> int printed;
> int missed;
> unsigned long begin;
> unsigned long flags;
>};
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/ratelimit_types.h"
>extern int ___ratelimit(struct ratelimit_state *rs, const char *func);
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/once_lite.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 2
>
>extern const char linux_banner[];
>extern const char linux_proc_banner[];
>
>extern int oops_in_progress;
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int printk_get_level(const char *buffer)
>{
> if (buffer[0] == '\001' && buffer[1]) {
>  switch (buffer[1]) {
>  case '0' ... '7':
>  case 'c':
>   return buffer[1];
>  }
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *printk_skip_level(const char *buffer)
>{
> if (printk_get_level(buffer))
>  return buffer + 2;
>
> return buffer;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *printk_skip_headers(const char *buffer)
>{
> while (printk_get_level(buffer))
>  buffer = printk_skip_level(buffer);
>
> return buffer;
>}
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
>extern int console_printk[];
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void console_silent(void)
>{
> (console_printk[0]) = 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void console_verbose(void)
>{
> if ((console_printk[0]))
>  (console_printk[0]) = 15;
>}
>
>
>
>extern char devkmsg_log_str[];
>struct ctl_table;
>
>extern int suppress_printk;
>
>struct va_format {
> const char *fmt;
> va_list *va;
>};
># 146 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
>extern __attribute__((__format__(printf, 1, 2)))
>void early_printk(const char *fmt, ...);
>
>
>
>
>
>struct dev_printk_info;
>
>
> __attribute__((__format__(printf, 4, 0)))
>int vprintk_emit(int facility, int level,
>   const struct dev_printk_info *dev_info,
>   const char *fmt, va_list args);
>
> __attribute__((__format__(printf, 1, 0)))
>int vprintk(const char *fmt, va_list args);
>
> __attribute__((__format__(printf, 1, 2))) __attribute__((__cold__))
>int printk(const char *fmt, ...);
>
>
>
>
>__attribute__((__format__(printf, 1, 2))) __attribute__((__cold__)) int printk_deferred(const char *fmt, ...);
>
>extern void __printk_safe_enter(void);
>extern void __printk_safe_exit(void);
># 187 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
>extern int __printk_ratelimit(const char *func);
>
>extern bool printk_timed_ratelimit(unsigned long *caller_jiffies,
>       unsigned int interval_msec);
>
>extern int printk_delay_msec;
>extern int dmesg_restrict;
>
>extern int
>devkmsg_sysctl_set_loglvl(struct ctl_table *table, int write, void *buf,
>     size_t *lenp, loff_t *ppos);
>
>extern void wake_up_klogd(void);
>
>void printk_bust_locks(void);
>
>char *log_buf_addr_get(void);
>u32 log_buf_len_get(void);
>void log_buf_vmcoreinfo_setup(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) setup_log_buf(int early);
>__attribute__((__format__(printf, 1, 2))) void dump_stack_set_arch_desc(const char *fmt, ...);
>void dump_stack_print_info(const char *log_lvl);
>void show_regs_print_info(const char *log_lvl);
>extern void dump_stack_lvl(const char *log_lvl) __attribute__((__cold__));
>extern void dump_stack(void) __attribute__((__cold__));
>void printk_trigger_flush(void);
># 299 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
>extern int __printk_cpu_trylock(void);
>extern void __printk_wait_on_cpu_lock(void);
>extern void __printk_cpu_unlock(void);
># 339 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
>extern int kptr_restrict;
># 463 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dynamic_debug.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h" 1
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
>extern bool static_key_initialized;
>
>
>
>
>
>
>
>struct static_key {
> atomic_t enabled;
># 102 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
> union {
>  unsigned long type;
>  struct jump_entry *entries;
>  struct static_key_mod *next;
> };
>};
># 117 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/jump_label.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/jump_label.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_static_branch(struct static_key *key, bool branch)
>{
> do { asm goto("1:" "jmp %l[l_yes] # objtool NOPs this \n\t" ".pushsection __jump_table,  \"aw\" \n\t" " " ".balign 8" " " "\n\t" ".long 1b - . \n\t" ".long %l[l_yes] - . \n\t" " " ".quad" " " "%c0 + %c1 - .\n\t" ".popsection \n\t" : : "i" (key), "i" (2 | branch) : : l_yes); asm (""); } while (0)
>
>
>                                             ;
>
> return false;
>l_yes:
> return true;
>}
># 53 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/jump_label.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_static_branch_jump(struct static_key * const key, const bool branch)
>{
> do { asm goto("1:" "jmp %l[l_yes]\n\t" ".pushsection __jump_table,  \"aw\" \n\t" " " ".balign 8" " " "\n\t" ".long 1b - . \n\t" ".long %l[l_yes] - . \n\t" " " ".quad" " " "%c0 + %c1 - .\n\t" ".popsection \n\t" : : "i" (key), "i" (branch) : : l_yes); asm (""); } while (0)
>
>
>                                         ;
>
> return false;
>l_yes:
> return true;
>}
>
>extern int arch_jump_entry_size(struct jump_entry *entry);
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h" 2
>
>
>
>
>struct jump_entry {
> s32 code;
> s32 target;
> long key;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long jump_entry_code(const struct jump_entry *entry)
>{
> return (unsigned long)&entry->code + entry->code;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long jump_entry_target(const struct jump_entry *entry)
>{
> return (unsigned long)&entry->target + entry->target;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct static_key *jump_entry_key(const struct jump_entry *entry)
>{
> long offset = entry->key & ~3L;
>
> return (struct static_key *)((unsigned long)&entry->key + offset);
>}
># 164 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool jump_entry_is_branch(const struct jump_entry *entry)
>{
> return (unsigned long)entry->key & 1UL;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool jump_entry_is_init(const struct jump_entry *entry)
>{
> return (unsigned long)entry->key & 2UL;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void jump_entry_set_init(struct jump_entry *entry, bool set)
>{
> if (set)
>  entry->key |= 2;
> else
>  entry->key &= ~2;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int jump_entry_size(struct jump_entry *entry)
>{
>
>
>
> return arch_jump_entry_size(entry);
>
>}
>
>
>
>
>
>
>enum jump_label_type {
> JUMP_LABEL_NOP = 0,
> JUMP_LABEL_JMP,
>};
>
>struct module;
># 210 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool static_key_false(struct static_key *key)
>{
> return arch_static_branch(key, false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool static_key_true(struct static_key *key)
>{
> return !arch_static_branch(key, true);
>}
>
>extern struct jump_entry __start___jump_table[];
>extern struct jump_entry __stop___jump_table[];
>
>extern void jump_label_init(void);
>extern void jump_label_lock(void);
>extern void jump_label_unlock(void);
>extern void arch_jump_label_transform(struct jump_entry *entry,
>          enum jump_label_type type);
>extern void arch_jump_label_transform_static(struct jump_entry *entry,
>          enum jump_label_type type);
>extern bool arch_jump_label_transform_queue(struct jump_entry *entry,
>         enum jump_label_type type);
>extern void arch_jump_label_transform_apply(void);
>extern int jump_label_text_reserved(void *start, void *end);
>extern void static_key_slow_inc(struct static_key *key);
>extern void static_key_slow_dec(struct static_key *key);
>extern void static_key_slow_inc_cpuslocked(struct static_key *key);
>extern void static_key_slow_dec_cpuslocked(struct static_key *key);
>extern void jump_label_apply_nops(struct module *mod);
>extern int static_key_count(struct static_key *key);
>extern void static_key_enable(struct static_key *key);
>extern void static_key_disable(struct static_key *key);
>extern void static_key_enable_cpuslocked(struct static_key *key);
>extern void static_key_disable_cpuslocked(struct static_key *key);
># 358 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
>struct static_key_true {
> struct static_key key;
>};
>
>struct static_key_false {
> struct static_key key;
>};
># 412 "/usr/src/linux-5.14.21-150500.53/include/linux/jump_label.h"
>extern bool ____wrong_branch_error(void);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/dynamic_debug.h" 2
>
>
>
>
>
>
>
>struct _ddebug {
>
>
>
>
> const char *modname;
> const char *function;
> const char *filename;
> const char *format;
> unsigned int lineno:18;
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/dynamic_debug.h"
> unsigned int flags:8;
>
> union {
>  struct static_key_true dd_key_true;
>  struct static_key_false dd_key_false;
> } key;
>
>} __attribute__((aligned(8)));
>
>
>
>
>
>
>int dynamic_debug_exec_queries(const char *query, const char *modname);
>
>int ddebug_add_module(struct _ddebug *tab, unsigned int n,
>    const char *modname);
>extern int ddebug_remove_module(const char *mod_name);
>extern __attribute__((__format__(printf, 2, 3)))
>void __dynamic_pr_debug(struct _ddebug *descriptor, const char *fmt, ...);
>
>extern int ddebug_dyndbg_module_param_cb(char *param, char *val,
>     const char *modname);
>
>struct device;
>
>extern __attribute__((__format__(printf, 3, 4)))
>void __dynamic_dev_dbg(struct _ddebug *descriptor, const struct device *dev,
>         const char *fmt, ...);
>
>struct net_device;
>
>extern __attribute__((__format__(printf, 3, 4)))
>void __dynamic_netdev_dbg(struct _ddebug *descriptor,
>     const struct net_device *dev,
>     const char *fmt, ...);
>
>struct ib_device;
>
>extern __attribute__((__format__(printf, 3, 4)))
>void __dynamic_ibdev_dbg(struct _ddebug *descriptor,
>    const struct ib_device *ibdev,
>    const char *fmt, ...);
># 464 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h" 2
># 601 "/usr/src/linux-5.14.21-150500.53/include/linux/printk.h"
>extern const struct file_operations kmsg_fops;
>
>enum {
> DUMP_PREFIX_NONE,
> DUMP_PREFIX_ADDRESS,
> DUMP_PREFIX_OFFSET
>};
>extern int hex_dump_to_buffer(const void *buf, size_t len, int rowsize,
>         int groupsize, char *linebuf, size_t linebuflen,
>         bool ascii);
>
>extern void print_hex_dump(const char *level, const char *prefix_str,
>      int prefix_type, int rowsize, int groupsize,
>      const void *buf, size_t len, bool ascii);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/static_call_types.h" 1
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/static_call_types.h"
>struct static_call_site {
> s32 addr;
> s32 key;
>};
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/static_call_types.h"
>struct static_call_key {
> void *func;
> union {
>
>  unsigned long type;
>  struct static_call_mod *mods;
>  struct static_call_site *sites;
> };
>};
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h" 2
># 87 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>struct completion;
>struct user;
># 97 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>extern int __cond_resched(void);
>
>extern struct static_call_key __SCK__might_resched; extern struct static_call_tramp __SCT__might_resched; extern typeof(__cond_resched) __SCtype__might_resched;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void might_resched(void)
>{
> ((typeof(&__SCtype__might_resched))&__SCT__might_resched)();
>}
># 170 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __might_resched(const char *file, int line,
>         unsigned int offsets) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __might_sleep(const char *file, int line) { }
># 188 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void might_fault(void) { }
>
>
>void do_exit(long error_code) __attribute__((__noreturn__));
>void complete_and_exit(struct completion *, long) __attribute__((__noreturn__));
>
>extern int num_to_str(char *buf, int size,
>        unsigned long long num, unsigned int width);
>
>
>
>extern __attribute__((__format__(printf, 2, 3))) int sprintf(char *buf, const char * fmt, ...);
>extern __attribute__((__format__(printf, 2, 0))) int vsprintf(char *buf, const char *, va_list);
>extern __attribute__((__format__(printf, 3, 4)))
>int snprintf(char *buf, size_t size, const char *fmt, ...);
>extern __attribute__((__format__(printf, 3, 0)))
>int vsnprintf(char *buf, size_t size, const char *fmt, va_list args);
>extern __attribute__((__format__(printf, 3, 4)))
>int scnprintf(char *buf, size_t size, const char *fmt, ...);
>extern __attribute__((__format__(printf, 3, 0)))
>int vscnprintf(char *buf, size_t size, const char *fmt, va_list args);
>extern __attribute__((__format__(printf, 2, 3))) __attribute__((__malloc__))
>char *kasprintf(gfp_t gfp, const char *fmt, ...);
>extern __attribute__((__format__(printf, 2, 0))) __attribute__((__malloc__))
>char *kvasprintf(gfp_t gfp, const char *fmt, va_list args);
>extern __attribute__((__format__(printf, 2, 0)))
>const char *kvasprintf_const(gfp_t gfp, const char *fmt, va_list args);
>
>extern __attribute__((__format__(scanf, 2, 3)))
>int sscanf(const char *, const char *, ...);
>extern __attribute__((__format__(scanf, 2, 0)))
>int vsscanf(const char *, const char *, va_list);
>
>extern int no_hash_pointers_enable(char *str);
>
>extern int get_option(char **str, int *pint);
>extern char *get_options(const char *str, int nints, int *ints);
>extern unsigned long long memparse(const char *ptr, char **retptr);
>extern bool parse_option_str(const char *str, const char *option);
>extern char *next_arg(char *args, char **param, char **val);
>
>extern int core_kernel_text(unsigned long addr);
>extern int init_kernel_text(unsigned long addr);
>extern int core_kernel_data(unsigned long addr);
>extern int __kernel_text_address(unsigned long addr);
>extern int kernel_text_address(unsigned long addr);
>extern int func_ptr_is_kernel_text(void *ptr);
>
>extern void bust_spinlocks(int yes);
>
>extern int root_mountflags;
>
>extern bool early_boot_irqs_disabled;
>
>
>
>
>
>extern enum system_states {
> SYSTEM_BOOTING,
> SYSTEM_SCHEDULING,
> SYSTEM_RUNNING,
> SYSTEM_HALT,
> SYSTEM_POWER_OFF,
> SYSTEM_RESTART,
> SYSTEM_SUSPEND,
>} system_state;
>
>extern const char hex_asc[];
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) char *hex_byte_pack(char *buf, u8 byte)
>{
> *buf++ = hex_asc[((byte) & 0xf0) >> 4];
> *buf++ = hex_asc[((byte) & 0x0f)];
> return buf;
>}
>
>extern const char hex_asc_upper[];
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) char *hex_byte_pack_upper(char *buf, u8 byte)
>{
> *buf++ = hex_asc_upper[((byte) & 0xf0) >> 4];
> *buf++ = hex_asc_upper[((byte) & 0x0f)];
> return buf;
>}
>
>extern int hex_to_bin(char ch);
>extern int __attribute__((__warn_unused_result__)) hex2bin(u8 *dst, const char *src, size_t count);
>extern char *bin2hex(char *dst, const void *src, size_t count);
>
>bool mac_pton(const char *s, u8 *mac);
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>enum ftrace_dump_mode {
> DUMP_NONE,
> DUMP_ALL,
> DUMP_ORIG,
>};
>
>
>void tracing_on(void);
>void tracing_off(void);
>int tracing_is_on(void);
>void tracing_snapshot(void);
>void tracing_snapshot_alloc(void);
>
>extern void tracing_start(void);
>extern void tracing_stop(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__format__(printf, 1, 2)))
>void ____trace_printk_check_format(const char *fmt, ...)
>{
>}
># 383 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>extern __attribute__((__format__(printf, 2, 3)))
>int __trace_bprintk(unsigned long ip, const char *fmt, ...);
>
>extern __attribute__((__format__(printf, 2, 3)))
>int __trace_printk(unsigned long ip, const char *fmt, ...);
># 424 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>extern int __trace_bputs(unsigned long ip, const char *str);
>extern int __trace_puts(unsigned long ip, const char *str, int size);
>
>extern void trace_dump_stack(int skip);
># 446 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel.h"
>extern __attribute__((__format__(printf, 2, 0))) int
>__ftrace_vbprintk(unsigned long ip, const char *fmt, va_list ap);
>
>extern __attribute__((__format__(printf, 2, 0))) int
>__ftrace_vprintk(unsigned long ip, const char *fmt, va_list ap);
>
>extern void ftrace_dump(enum ftrace_dump_mode oops_dump_mode);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h" 2
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void INIT_LIST_HEAD(struct list_head *list)
>{
> do { do { extern void __compiletime_assert_0(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(list->next) == sizeof(char) || sizeof(list->next) == sizeof(short) || sizeof(list->next) == sizeof(int) || sizeof(list->next) == sizeof(long)) || sizeof(list->next) == sizeof(long long))) __compiletime_assert_0(); } while (0); do { *(volatile typeof(list->next) *)&(list->next) = (list); } while (0); } while (0);
> do { do { extern void __compiletime_assert_1(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(list->prev) == sizeof(char) || sizeof(list->prev) == sizeof(short) || sizeof(list->prev) == sizeof(int) || sizeof(list->prev) == sizeof(long)) || sizeof(list->prev) == sizeof(long long))) __compiletime_assert_1(); } while (0); do { *(volatile typeof(list->prev) *)&(list->prev) = (list); } while (0); } while (0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __list_add_valid(struct list_head *new,
>    struct list_head *prev,
>    struct list_head *next)
>{
> return true;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __list_del_entry_valid(struct list_head *entry)
>{
> return true;
>}
># 63 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_add(struct list_head *new,
>         struct list_head *prev,
>         struct list_head *next)
>{
> if (!__list_add_valid(new, prev, next))
>  return;
>
> next->prev = new;
> new->next = next;
> new->prev = prev;
> do { do { extern void __compiletime_assert_2(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(prev->next) == sizeof(char) || sizeof(prev->next) == sizeof(short) || sizeof(prev->next) == sizeof(int) || sizeof(prev->next) == sizeof(long)) || sizeof(prev->next) == sizeof(long long))) __compiletime_assert_2(); } while (0); do { *(volatile typeof(prev->next) *)&(prev->next) = (new); } while (0); } while (0);
>}
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_add(struct list_head *new, struct list_head *head)
>{
> __list_add(new, head, head->next);
>}
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_add_tail(struct list_head *new, struct list_head *head)
>{
> __list_add(new, head->prev, head);
>}
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_del(struct list_head * prev, struct list_head * next)
>{
> next->prev = prev;
> do { do { extern void __compiletime_assert_3(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(prev->next) == sizeof(char) || sizeof(prev->next) == sizeof(short) || sizeof(prev->next) == sizeof(int) || sizeof(prev->next) == sizeof(long)) || sizeof(prev->next) == sizeof(long long))) __compiletime_assert_3(); } while (0); do { *(volatile typeof(prev->next) *)&(prev->next) = (next); } while (0); } while (0);
>}
># 124 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_del_clearprev(struct list_head *entry)
>{
> __list_del(entry->prev, entry->next);
> entry->prev = ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_del_entry(struct list_head *entry)
>{
> if (!__list_del_entry_valid(entry))
>  return;
>
> __list_del(entry->prev, entry->next);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_del(struct list_head *entry)
>{
> __list_del_entry(entry);
> entry->next = ((void *) 0x100 + (0xdead000000000000UL));
> entry->prev = ((void *) 0x122 + (0xdead000000000000UL));
>}
># 158 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_replace(struct list_head *old,
>    struct list_head *new)
>{
> new->next = old->next;
> new->next->prev = new;
> new->prev = old->prev;
> new->prev->next = new;
>}
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_replace_init(struct list_head *old,
>         struct list_head *new)
>{
> list_replace(old, new);
> INIT_LIST_HEAD(old);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_swap(struct list_head *entry1,
>        struct list_head *entry2)
>{
> struct list_head *pos = entry2->prev;
>
> list_del(entry2);
> list_replace(entry1, entry2);
> if (pos == entry1)
>  pos = entry2;
> list_add(entry1, pos);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_del_init(struct list_head *entry)
>{
> __list_del_entry(entry);
> INIT_LIST_HEAD(entry);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_move(struct list_head *list, struct list_head *head)
>{
> __list_del_entry(list);
> list_add(list, head);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_move_tail(struct list_head *list,
>      struct list_head *head)
>{
> __list_del_entry(list);
> list_add_tail(list, head);
>}
># 240 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_bulk_move_tail(struct list_head *head,
>           struct list_head *first,
>           struct list_head *last)
>{
> first->prev->next = last->next;
> last->next->prev = first->prev;
>
> head->prev->next = first;
> first->prev = head->prev;
>
> last->next = head;
> head->prev = last;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int list_is_first(const struct list_head *list, const struct list_head *head)
>{
> return list->prev == head;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int list_is_last(const struct list_head *list, const struct list_head *head)
>{
> return list->next == head;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int list_is_head(const struct list_head *list, const struct list_head *head)
>{
> return list == head;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int list_empty(const struct list_head *head)
>{
> return ({ do { extern void __compiletime_assert_4(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(head->next) == sizeof(char) || sizeof(head->next) == sizeof(short) || sizeof(head->next) == sizeof(int) || sizeof(head->next) == sizeof(long)) || sizeof(head->next) == sizeof(long long))) __compiletime_assert_4(); } while (0); (*(const volatile typeof( _Generic((head->next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head->next))) *)&(head->next)); }) == head;
>}
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_del_init_careful(struct list_head *entry)
>{
> __list_del_entry(entry);
> do { do { extern void __compiletime_assert_5(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(entry->prev) == sizeof(char) || sizeof(entry->prev) == sizeof(short) || sizeof(entry->prev) == sizeof(int) || sizeof(entry->prev) == sizeof(long)) || sizeof(entry->prev) == sizeof(long long))) __compiletime_assert_5(); } while (0); do { *(volatile typeof(entry->prev) *)&(entry->prev) = (entry); } while (0); } while (0);
> do { do { extern void __compiletime_assert_6(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&entry->next) == sizeof(char) || sizeof(*&entry->next) == sizeof(short) || sizeof(*&entry->next) == sizeof(int) || sizeof(*&entry->next) == sizeof(long)))) __compiletime_assert_6(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_7(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&entry->next) == sizeof(char) || sizeof(*&entry->next) == sizeof(short) || sizeof(*&entry->next) == sizeof(int) || sizeof(*&entry->next) == sizeof(long)) || sizeof(*&entry->next) == sizeof(long long))) __compiletime_assert_7(); } while (0); do { *(volatile typeof(*&entry->next) *)&(*&entry->next) = (entry); } while (0); } while (0); } while (0);
>}
># 324 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int list_empty_careful(const struct list_head *head)
>{
> struct list_head *next = ({ typeof(*&head->next) ___p1 = ({ do { extern void __compiletime_assert_8(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&head->next) == sizeof(char) || sizeof(*&head->next) == sizeof(short) || sizeof(*&head->next) == sizeof(int) || sizeof(*&head->next) == sizeof(long)) || sizeof(*&head->next) == sizeof(long long))) __compiletime_assert_8(); } while (0); (*(const volatile typeof( _Generic((*&head->next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&head->next))) *)&(*&head->next)); }); do { extern void __compiletime_assert_9(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&head->next) == sizeof(char) || sizeof(*&head->next) == sizeof(short) || sizeof(*&head->next) == sizeof(int) || sizeof(*&head->next) == sizeof(long)))) __compiletime_assert_9(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
> return list_is_head(next, head) && (next == ({ do { extern void __compiletime_assert_10(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(head->prev) == sizeof(char) || sizeof(head->prev) == sizeof(short) || sizeof(head->prev) == sizeof(int) || sizeof(head->prev) == sizeof(long)) || sizeof(head->prev) == sizeof(long long))) __compiletime_assert_10(); } while (0); (*(const volatile typeof( _Generic((head->prev), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head->prev))) *)&(head->prev)); }));
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_rotate_left(struct list_head *head)
>{
> struct list_head *first;
>
> if (!list_empty(head)) {
>  first = head->next;
>  list_move_tail(first, head);
> }
>}
># 351 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_rotate_to_front(struct list_head *list,
>     struct list_head *head)
>{
>
>
>
>
>
> list_move_tail(head, list);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int list_is_singular(const struct list_head *head)
>{
> return !list_empty(head) && (head->next == head->prev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_cut_position(struct list_head *list,
>  struct list_head *head, struct list_head *entry)
>{
> struct list_head *new_first = entry->next;
> list->next = head->next;
> list->next->prev = list;
> list->prev = entry;
> entry->next = list;
> head->next = new_first;
> new_first->prev = head;
>}
># 397 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_cut_position(struct list_head *list,
>  struct list_head *head, struct list_head *entry)
>{
> if (list_empty(head))
>  return;
> if (list_is_singular(head) && !list_is_head(entry, head) && (entry != head->next))
>  return;
> if (list_is_head(entry, head))
>  INIT_LIST_HEAD(list);
> else
>  __list_cut_position(list, head, entry);
>}
># 424 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_cut_before(struct list_head *list,
>       struct list_head *head,
>       struct list_head *entry)
>{
> if (head->next == entry) {
>  INIT_LIST_HEAD(list);
>  return;
> }
> list->next = head->next;
> list->next->prev = list;
> list->prev = entry->prev;
> list->prev->next = list;
> head->next = entry;
> entry->prev = head;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_splice(const struct list_head *list,
>     struct list_head *prev,
>     struct list_head *next)
>{
> struct list_head *first = list->next;
> struct list_head *last = list->prev;
>
> first->prev = prev;
> prev->next = first;
>
> last->next = next;
> next->prev = last;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_splice(const struct list_head *list,
>    struct list_head *head)
>{
> if (!list_empty(list))
>  __list_splice(list, head, head->next);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_splice_tail(struct list_head *list,
>    struct list_head *head)
>{
> if (!list_empty(list))
>  __list_splice(list, head->prev, head);
>}
># 485 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_splice_init(struct list_head *list,
>        struct list_head *head)
>{
> if (!list_empty(list)) {
>  __list_splice(list, head, head->next);
>  INIT_LIST_HEAD(list);
> }
>}
># 502 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_splice_tail_init(struct list_head *list,
>      struct list_head *head)
>{
> if (!list_empty(list)) {
>  __list_splice(list, head->prev, head);
>  INIT_LIST_HEAD(list);
> }
>}
># 800 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void INIT_HLIST_NODE(struct hlist_node *h)
>{
> h->next = ((void *)0);
> h->pprev = ((void *)0);
>}
># 814 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int hlist_unhashed(const struct hlist_node *h)
>{
> return !h->pprev;
>}
># 827 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int hlist_unhashed_lockless(const struct hlist_node *h)
>{
> return !({ do { extern void __compiletime_assert_11(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(h->pprev) == sizeof(char) || sizeof(h->pprev) == sizeof(short) || sizeof(h->pprev) == sizeof(int) || sizeof(h->pprev) == sizeof(long)) || sizeof(h->pprev) == sizeof(long long))) __compiletime_assert_11(); } while (0); (*(const volatile typeof( _Generic((h->pprev), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (h->pprev))) *)&(h->pprev)); });
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int hlist_empty(const struct hlist_head *h)
>{
> return !({ do { extern void __compiletime_assert_12(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(h->first) == sizeof(char) || sizeof(h->first) == sizeof(short) || sizeof(h->first) == sizeof(int) || sizeof(h->first) == sizeof(long)) || sizeof(h->first) == sizeof(long long))) __compiletime_assert_12(); } while (0); (*(const volatile typeof( _Generic((h->first), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (h->first))) *)&(h->first)); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __hlist_del(struct hlist_node *n)
>{
> struct hlist_node *next = n->next;
> struct hlist_node **pprev = n->pprev;
>
> do { do { extern void __compiletime_assert_13(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pprev) == sizeof(char) || sizeof(*pprev) == sizeof(short) || sizeof(*pprev) == sizeof(int) || sizeof(*pprev) == sizeof(long)) || sizeof(*pprev) == sizeof(long long))) __compiletime_assert_13(); } while (0); do { *(volatile typeof(*pprev) *)&(*pprev) = (next); } while (0); } while (0);
> if (next)
>  do { do { extern void __compiletime_assert_14(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(next->pprev) == sizeof(char) || sizeof(next->pprev) == sizeof(short) || sizeof(next->pprev) == sizeof(int) || sizeof(next->pprev) == sizeof(long)) || sizeof(next->pprev) == sizeof(long long))) __compiletime_assert_14(); } while (0); do { *(volatile typeof(next->pprev) *)&(next->pprev) = (pprev); } while (0); } while (0);
>}
># 858 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_del(struct hlist_node *n)
>{
> __hlist_del(n);
> n->next = ((void *) 0x100 + (0xdead000000000000UL));
> n->pprev = ((void *) 0x122 + (0xdead000000000000UL));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_del_init(struct hlist_node *n)
>{
> if (!hlist_unhashed(n)) {
>  __hlist_del(n);
>  INIT_HLIST_NODE(n);
> }
>}
># 887 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_head(struct hlist_node *n, struct hlist_head *h)
>{
> struct hlist_node *first = h->first;
> do { do { extern void __compiletime_assert_15(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->next) == sizeof(char) || sizeof(n->next) == sizeof(short) || sizeof(n->next) == sizeof(int) || sizeof(n->next) == sizeof(long)) || sizeof(n->next) == sizeof(long long))) __compiletime_assert_15(); } while (0); do { *(volatile typeof(n->next) *)&(n->next) = (first); } while (0); } while (0);
> if (first)
>  do { do { extern void __compiletime_assert_16(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(first->pprev) == sizeof(char) || sizeof(first->pprev) == sizeof(short) || sizeof(first->pprev) == sizeof(int) || sizeof(first->pprev) == sizeof(long)) || sizeof(first->pprev) == sizeof(long long))) __compiletime_assert_16(); } while (0); do { *(volatile typeof(first->pprev) *)&(first->pprev) = (&n->next); } while (0); } while (0);
> do { do { extern void __compiletime_assert_17(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(h->first) == sizeof(char) || sizeof(h->first) == sizeof(short) || sizeof(h->first) == sizeof(int) || sizeof(h->first) == sizeof(long)) || sizeof(h->first) == sizeof(long long))) __compiletime_assert_17(); } while (0); do { *(volatile typeof(h->first) *)&(h->first) = (n); } while (0); } while (0);
> do { do { extern void __compiletime_assert_18(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_18(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&h->first); } while (0); } while (0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_before(struct hlist_node *n,
>        struct hlist_node *next)
>{
> do { do { extern void __compiletime_assert_19(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_19(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (next->pprev); } while (0); } while (0);
> do { do { extern void __compiletime_assert_20(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->next) == sizeof(char) || sizeof(n->next) == sizeof(short) || sizeof(n->next) == sizeof(int) || sizeof(n->next) == sizeof(long)) || sizeof(n->next) == sizeof(long long))) __compiletime_assert_20(); } while (0); do { *(volatile typeof(n->next) *)&(n->next) = (next); } while (0); } while (0);
> do { do { extern void __compiletime_assert_21(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(next->pprev) == sizeof(char) || sizeof(next->pprev) == sizeof(short) || sizeof(next->pprev) == sizeof(int) || sizeof(next->pprev) == sizeof(long)) || sizeof(next->pprev) == sizeof(long long))) __compiletime_assert_21(); } while (0); do { *(volatile typeof(next->pprev) *)&(next->pprev) = (&n->next); } while (0); } while (0);
> do { do { extern void __compiletime_assert_22(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*(n->pprev)) == sizeof(char) || sizeof(*(n->pprev)) == sizeof(short) || sizeof(*(n->pprev)) == sizeof(int) || sizeof(*(n->pprev)) == sizeof(long)) || sizeof(*(n->pprev)) == sizeof(long long))) __compiletime_assert_22(); } while (0); do { *(volatile typeof(*(n->pprev)) *)&(*(n->pprev)) = (n); } while (0); } while (0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_behind(struct hlist_node *n,
>        struct hlist_node *prev)
>{
> do { do { extern void __compiletime_assert_23(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->next) == sizeof(char) || sizeof(n->next) == sizeof(short) || sizeof(n->next) == sizeof(int) || sizeof(n->next) == sizeof(long)) || sizeof(n->next) == sizeof(long long))) __compiletime_assert_23(); } while (0); do { *(volatile typeof(n->next) *)&(n->next) = (prev->next); } while (0); } while (0);
> do { do { extern void __compiletime_assert_24(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(prev->next) == sizeof(char) || sizeof(prev->next) == sizeof(short) || sizeof(prev->next) == sizeof(int) || sizeof(prev->next) == sizeof(long)) || sizeof(prev->next) == sizeof(long long))) __compiletime_assert_24(); } while (0); do { *(volatile typeof(prev->next) *)&(prev->next) = (n); } while (0); } while (0);
> do { do { extern void __compiletime_assert_25(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_25(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&prev->next); } while (0); } while (0);
>
> if (n->next)
>  do { do { extern void __compiletime_assert_26(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->next->pprev) == sizeof(char) || sizeof(n->next->pprev) == sizeof(short) || sizeof(n->next->pprev) == sizeof(int) || sizeof(n->next->pprev) == sizeof(long)) || sizeof(n->next->pprev) == sizeof(long long))) __compiletime_assert_26(); } while (0); do { *(volatile typeof(n->next->pprev) *)&(n->next->pprev) = (&n->next); } while (0); } while (0);
>}
># 935 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_fake(struct hlist_node *n)
>{
> n->pprev = &n->next;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool hlist_fake(struct hlist_node *h)
>{
> return h->pprev == &h->next;
>}
># 957 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>hlist_is_singular_node(struct hlist_node *n, struct hlist_head *h)
>{
> return !n->next && n->pprev == &h->first;
>}
># 971 "/usr/src/linux-5.14.21-150500.53/include/linux/list.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_move_list(struct hlist_head *old,
>       struct hlist_head *new)
>{
> new->first = old->first;
> if (new->first)
>  new->first->pprev = &new->first;
> old->first = ((void *)0);
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h" 2
># 78 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/preempt.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/percpu.h" 1
># 358 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/percpu.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool x86_this_cpu_constant_test_bit(unsigned int nr,
>                        const unsigned long *addr)
>{
> unsigned long *a =
>  (unsigned long *)addr + nr / 64;
>
>
> return ((1UL << (nr % 64)) & ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (*a)); (typeof(*a))(unsigned long) pfo_val__; })) != 0;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool x86_this_cpu_variable_test_bit(int nr,
>                        const unsigned long *addr)
>{
> bool oldbit;
>
> asm volatile("btl ""%%""gs"":" "%" "2"",%1"
>   "\n\t/* output condition code " "c" "*/\n"
>   : "=@cc" "c" (oldbit)
>   : "m" (*(unsigned long *)addr), "Ir" (nr));
>
> return oldbit;
>}
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/percpu.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/threads.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/percpu.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-defs.h" 1
># 308 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-defs.h"
>extern void __bad_size_call_parameter(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __this_cpu_preempt_check(const char *op) { }
># 8 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/percpu.h" 2
># 19 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/percpu.h"
>extern unsigned long __per_cpu_offset[8192];
># 48 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/percpu.h"
>extern void setup_per_cpu_areas(void);
># 391 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/percpu.h" 2
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_this_cpu_off; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(unsigned long) this_cpu_off;
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/preempt.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bug.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bug.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/instrumentation.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bug.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/objtool.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/objtool.h"
>struct unwind_hint {
> u32 ip;
> s16 sp_offset;
> u8 sp_reg;
> u8 type;
> u8 end;
>};
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bug.h" 2
># 85 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bug.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bug.h" 1
># 27 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bug.h"
>struct bug_entry {
>
>
>
> signed int bug_addr_disp;
>
>
>
>
>
> signed int file_disp;
>
> unsigned short line;
>
> unsigned short flags;
>};
># 95 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bug.h"
>extern __attribute__((__format__(printf, 1, 2))) void __warn_printk(const char *fmt, ...);
># 113 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/bug.h"
>struct warn_args;
>struct pt_regs;
>
>void __warn(const char *file, int line, void *caller, unsigned taint,
>     struct pt_regs *regs, struct warn_args *args);
># 86 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/bug.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/bug.h" 2
>
>
>
>enum bug_trap_type {
> BUG_TRAP_TYPE_NONE = 0,
> BUG_TRAP_TYPE_WARN = 1,
> BUG_TRAP_TYPE_BUG = 2,
>};
>
>struct pt_regs;
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/bug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_warning_bug(const struct bug_entry *bug)
>{
> return bug->flags & (1 << 0);
>}
>
>void bug_get_file_line(struct bug_entry *bug, const char **file,
>         unsigned int *line);
>
>struct bug_entry *find_bug(unsigned long bugaddr);
>
>enum bug_trap_type report_bug(unsigned long bug_addr, struct pt_regs *regs);
>
>
>int is_valid_bugaddr(unsigned long addr);
>
>void generic_bug_clear_once(void);
># 80 "/usr/src/linux-5.14.21-150500.53/include/linux/bug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool check_data_corruption(bool v) { return v; }
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/restart_block.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/restart_block.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/math64.h" 1
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u32
>__iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder)
>{
> u32 ret = 0;
>
> while (dividend >= divisor) {
>
>
>  asm("" : "+rm"(dividend));
>
>  dividend -= divisor;
>  ret++;
> }
>
> *remainder = dividend;
>
> return ret;
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h" 2
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 div_u64_rem(u64 dividend, u32 divisor, u32 *remainder)
>{
> *remainder = dividend % divisor;
> return dividend / divisor;
>}
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 div_s64_rem(s64 dividend, s32 divisor, s32 *remainder)
>{
> *remainder = dividend % divisor;
> return dividend / divisor;
>}
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 div64_u64_rem(u64 dividend, u64 divisor, u64 *remainder)
>{
> *remainder = dividend % divisor;
> return dividend / divisor;
>}
># 67 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 div64_u64(u64 dividend, u64 divisor)
>{
> return dividend / divisor;
>}
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 div64_s64(s64 dividend, s64 divisor)
>{
> return dividend / divisor;
>}
># 125 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 div_u64(u64 dividend, u32 divisor)
>{
> u32 remainder;
> return div_u64_rem(dividend, divisor, &remainder);
>}
># 138 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 div_s64(s64 dividend, s32 divisor)
>{
> s32 remainder;
> return div_s64_rem(dividend, divisor, &remainder);
>}
>
>
>u32 iter_div_u64_rem(u64 dividend, u32 divisor, u64 *remainder);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 mul_u32_u32(u32 a, u32 b)
>{
> return (u64)a * b;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 mul_u64_u32_shr(u64 a, u32 mul, unsigned int shift)
>{
> return (u64)(((unsigned __int128)a * mul) >> shift);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 mul_u64_u64_shr(u64 a, u64 mul, unsigned int shift)
>{
> return (u64)(((unsigned __int128)a * mul) >> shift);
>}
># 239 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 mul_s64_u64_shr(s64 a, u64 b, unsigned int shift)
>{
> u64 ret;
>
>
>
>
>
> ret = mul_u64_u64_shr(__builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed long long) || __builtin_types_compatible_p(typeof(a), unsigned long long), ({ signed long long __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed long) || __builtin_types_compatible_p(typeof(a), unsigned long), ({ signed long __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed int) || __builtin_types_compatible_p(typeof(a), unsigned int), ({ signed int __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed short) || __builtin_types_compatible_p(typeof(a), unsigned short), ({ signed short __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), signed char) || __builtin_types_compatible_p(typeof(a), unsigned char), ({ signed char __x = (a); __x < 0 ? -__x : __x; }), __builtin_choose_expr( __builtin_types_compatible_p(typeof(a), char), (char)({ signed char __x = (a); __x<0?-__x:__x; }), ((void)0))))))), b, shift);
>
> if (a < 0)
>  ret = -((s64) ret);
>
> return ret;
>}
># 285 "/usr/src/linux-5.14.21-150500.53/include/linux/math64.h"
>u64 mul_u64_u64_div_u64(u64 a, u64 mul, u64 div);
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/time64.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h" 2
>
>typedef __s64 time64_t;
>typedef __u64 timeu64_t;
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/time.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/time_types.h" 1
>
>
>
>
>
>
>struct __kernel_timespec {
> __kernel_time64_t tv_sec;
> long long tv_nsec;
>};
>
>struct __kernel_itimerspec {
> struct __kernel_timespec it_interval;
> struct __kernel_timespec it_value;
>};
># 25 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/time_types.h"
>struct __kernel_old_timeval {
> __kernel_long_t tv_sec;
> __kernel_long_t tv_usec;
>};
>
>
>struct __kernel_old_timespec {
> __kernel_old_time_t tv_sec;
> long tv_nsec;
>};
>
>struct __kernel_old_itimerval {
> struct __kernel_old_timeval it_interval;
> struct __kernel_old_timeval it_value;
>};
>
>struct __kernel_sock_timeval {
> __s64 tv_sec;
> __s64 tv_usec;
>};
># 7 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/time.h" 2
># 33 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/time.h"
>struct timezone {
> int tz_minuteswest;
> int tz_dsttime;
>};
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h" 2
>
>struct timespec64 {
> time64_t tv_sec;
> long tv_nsec;
>};
>
>struct itimerspec64 {
> struct timespec64 it_interval;
> struct timespec64 it_value;
>};
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int timespec64_equal(const struct timespec64 *a,
>       const struct timespec64 *b)
>{
> return (a->tv_sec == b->tv_sec) && (a->tv_nsec == b->tv_nsec);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int timespec64_compare(const struct timespec64 *lhs, const struct timespec64 *rhs)
>{
> if (lhs->tv_sec < rhs->tv_sec)
>  return -1;
> if (lhs->tv_sec > rhs->tv_sec)
>  return 1;
> return lhs->tv_nsec - rhs->tv_nsec;
>}
>
>extern void set_normalized_timespec64(struct timespec64 *ts, time64_t sec, s64 nsec);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct timespec64 timespec64_add(struct timespec64 lhs,
>      struct timespec64 rhs)
>{
> struct timespec64 ts_delta;
> set_normalized_timespec64(&ts_delta, lhs.tv_sec + rhs.tv_sec,
>    lhs.tv_nsec + rhs.tv_nsec);
> return ts_delta;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct timespec64 timespec64_sub(struct timespec64 lhs,
>      struct timespec64 rhs)
>{
> struct timespec64 ts_delta;
> set_normalized_timespec64(&ts_delta, lhs.tv_sec - rhs.tv_sec,
>    lhs.tv_nsec - rhs.tv_nsec);
> return ts_delta;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool timespec64_valid(const struct timespec64 *ts)
>{
>
> if (ts->tv_sec < 0)
>  return false;
>
> if ((unsigned long)ts->tv_nsec >= 1000000000L)
>  return false;
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool timespec64_valid_strict(const struct timespec64 *ts)
>{
> if (!timespec64_valid(ts))
>  return false;
>
> if ((unsigned long long)ts->tv_sec >= (((s64)~((u64)1 << 63)) / 1000000000L))
>  return false;
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool timespec64_valid_settod(const struct timespec64 *ts)
>{
> if (!timespec64_valid(ts))
>  return false;
>
> if ((unsigned long long)ts->tv_sec >= ((((s64)~((u64)1 << 63)) / 1000000000L) - (30LL * 365 * 24 *3600)))
>  return false;
> return true;
>}
># 125 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 timespec64_to_ns(const struct timespec64 *ts)
>{
>
> if ((unsigned long long)ts->tv_sec >= (((s64)~((u64)1 << 63)) / 1000000000L))
>  return ((s64)~((u64)1 << 63));
>
> return ((s64) ts->tv_sec * 1000000000L) + ts->tv_nsec;
>}
>
>
>
>
>
>
>
>extern struct timespec64 ns_to_timespec64(s64 nsec);
># 150 "/usr/src/linux-5.14.21-150500.53/include/linux/time64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void timespec64_add_ns(struct timespec64 *a, u64 ns)
>{
> a->tv_sec += __iter_div_u64_rem(a->tv_nsec + ns, 1000000000L, &ns);
> a->tv_nsec = ns;
>}
>
>
>
>
>
>extern struct timespec64 timespec64_add_safe(const struct timespec64 lhs,
>      const struct timespec64 rhs);
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/restart_block.h" 2
>
>struct timespec;
>struct old_timespec32;
>struct pollfd;
>
>enum timespec_type {
> TT_NONE = 0,
> TT_NATIVE = 1,
> TT_COMPAT = 2,
>};
>
>
>
>
>struct restart_block {
> unsigned long arch_data;
> long (*fn)(struct restart_block *);
> union {
>
>  struct {
>   u32 *uaddr;
>   u32 val;
>   u32 flags;
>   u32 bitset;
>   u64 time;
>   u32 *uaddr2;
>  } futex;
>
>  struct {
>   clockid_t clockid;
>   enum timespec_type type;
>   union {
>    struct __kernel_timespec *rmtp;
>    struct old_timespec32 *compat_rmtp;
>   };
>   u64 expires;
>  } nanosleep;
>
>  struct {
>   struct pollfd *ufds;
>   int nfds;
>   int has_timeout;
>   unsigned long tv_sec;
>   unsigned long tv_nsec;
>  } poll;
> };
>};
>
>extern long do_no_restart_syscall(struct restart_block *parm);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/errno.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/errno.h" 1
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/errno.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/errno.h" 2
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h" 2
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/current.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/current.h"
>struct task_struct;
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_current_task; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct task_struct *) current_task;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct task_struct *get_current(void)
>{
> return ({ typeof(current_task) pscr_ret__; do { const void *__vpp_verify = (typeof((&(current_task)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(current_task)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm("mov" "b " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "p" (&(current_task))); (typeof(current_task))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm("mov" "w " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "p" (&(current_task))); (typeof(current_task))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm("mov" "l " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "p" (&(current_task))); (typeof(current_task))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm("mov" "q " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "p" (&(current_task))); (typeof(current_task))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; });
>}
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h" 2
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"
>enum {
> BAD_STACK = -1,
> NOT_STACK = 0,
> GOOD_FRAME,
> GOOD_STACK,
>};
>
>
>enum syscall_work_bit {
> SYSCALL_WORK_BIT_SECCOMP,
> SYSCALL_WORK_BIT_SYSCALL_TRACEPOINT,
> SYSCALL_WORK_BIT_SYSCALL_TRACE,
> SYSCALL_WORK_BIT_SYSCALL_EMU,
> SYSCALL_WORK_BIT_SYSCALL_AUDIT,
> SYSCALL_WORK_BIT_SYSCALL_USER_DISPATCH,
> SYSCALL_WORK_BIT_SYSCALL_EXIT_TRAP,
>};
># 60 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_types.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mem_encrypt.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/mem_encrypt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mem_encrypt.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mem_encrypt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
>enum cc_attr {
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
> CC_ATTR_MEM_ENCRYPT,
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
> CC_ATTR_HOST_MEM_ENCRYPT,
># 53 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
> CC_ATTR_GUEST_MEM_ENCRYPT,
># 63 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
> CC_ATTR_GUEST_STATE_ENCRYPT,
># 74 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
> CC_ATTR_GUEST_UNROLL_STRING_IO,
>
>
>
>
>
>
>
> CC_ATTR_GUEST_SEV_SNP,
># 92 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
> CC_ATTR_HOTPLUG_DISABLED,
>};
># 109 "/usr/src/linux-5.14.21-150500.53/include/linux/cc_platform.h"
>bool cc_platform_has(enum cc_attr attr);
># 17 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mem_encrypt.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h" 1
># 45 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/screen_info.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/screen_info.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/screen_info.h"
>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, 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));
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/screen_info.h" 2
>
>extern struct screen_info screen_info;
># 46 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/apm_bios.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/apm_bios.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/apm_bios.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/apm_bios.h"
>typedef unsigned short apm_event_t;
>typedef unsigned short apm_eventinfo_t;
>
>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;
>};
># 133 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/apm_bios.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ioctl.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/ioctl.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/ioctl.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/ioctl.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/ioctl.h" 2
>
>
>
>
>
>extern unsigned int __invalid_size_argument_for_IOC;
># 1 "./arch/x86/include/generated/uapi/asm/ioctl.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ioctl.h" 2
># 134 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/apm_bios.h" 2
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/apm_bios.h" 2
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/apm_bios.h"
>struct apm_info {
> struct apm_bios_info bios;
> unsigned short connection_version;
> int get_power_status_broken;
> int get_power_status_swabinminutes;
> int allow_ints;
> int forbid_idle;
> int realmode_power_off;
> int disabled;
>};
># 85 "/usr/src/linux-5.14.21-150500.53/include/linux/apm_bios.h"
>extern struct apm_info apm_info;
># 47 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/edd.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/edd.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/edd.h" 1
># 72 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/edd.h"
>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;
>  } __attribute__ ((packed)) isa;
>  struct {
>   __u8 bus;
>   __u8 slot;
>   __u8 function;
>   __u8 channel;
>   __u32 reserved;
>  } __attribute__ ((packed)) pci;
>
>  struct {
>   __u64 reserved;
>  } __attribute__ ((packed)) ibnd;
>  struct {
>   __u64 reserved;
>  } __attribute__ ((packed)) xprs;
>  struct {
>   __u64 reserved;
>  } __attribute__ ((packed)) htpt;
>  struct {
>   __u64 reserved;
>  } __attribute__ ((packed)) unknown;
> } interface_path;
> union {
>  struct {
>   __u8 device;
>   __u8 reserved1;
>   __u16 reserved2;
>   __u32 reserved3;
>   __u64 reserved4;
>  } __attribute__ ((packed)) ata;
>  struct {
>   __u8 device;
>   __u8 lun;
>   __u8 reserved1;
>   __u8 reserved2;
>   __u32 reserved3;
>   __u64 reserved4;
>  } __attribute__ ((packed)) atapi;
>  struct {
>   __u16 id;
>   __u64 lun;
>   __u16 reserved1;
>   __u32 reserved2;
>  } __attribute__ ((packed)) scsi;
>  struct {
>   __u64 serial_number;
>   __u64 reserved;
>  } __attribute__ ((packed)) usb;
>  struct {
>   __u64 eui;
>   __u64 reserved;
>  } __attribute__ ((packed)) i1394;
>  struct {
>   __u64 wwid;
>   __u64 lun;
>  } __attribute__ ((packed)) fibre;
>  struct {
>   __u64 identity_tag;
>   __u64 reserved;
>  } __attribute__ ((packed)) i2o;
>  struct {
>   __u32 array_number;
>   __u32 reserved1;
>   __u64 reserved2;
>  } __attribute__ ((packed)) raid;
>  struct {
>   __u8 device;
>   __u8 reserved1;
>   __u16 reserved2;
>   __u32 reserved3;
>   __u64 reserved4;
>  } __attribute__ ((packed)) sata;
>  struct {
>   __u64 reserved1;
>   __u64 reserved2;
>  } __attribute__ ((packed)) 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;
>} __attribute__ ((packed));
>
>struct edd {
> unsigned int mbr_signature[16];
> struct edd_info edd_info[6];
> unsigned char mbr_signature_nr;
> unsigned char edd_info_nr;
>};
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/edd.h" 2
>
>
>extern struct edd edd;
># 48 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ist.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ist.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ist.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ist.h"
>struct ist_info {
> __u32 signature;
> __u32 command;
> __u32 event;
> __u32 perf_level;
>};
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ist.h" 2
>
>
>extern struct ist_info ist_info;
># 49 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/video/edid.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/video/edid.h" 1
>
>
>
>
>struct edid_info {
> unsigned char dummy[128];
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/video/edid.h" 2
>
>
>extern struct edid_info edid_info;
># 50 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h" 2
>
>
>struct setup_data {
> __u64 next;
> __u32 type;
> __u32 len;
> __u8 data[0];
>};
>
>
>struct setup_indirect {
> __u32 type;
> __u32 reserved;
> __u64 len;
> __u64 addr;
>};
>
>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_seg;
> __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;
> __u32 kernel_info_offset;
>} __attribute__((packed));
>
>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;
>} __attribute__((packed));
>
>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;
>};
># 142 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h"
>struct boot_e820_entry {
> __u64 addr;
> __u64 size;
> __u32 type;
>} __attribute__((packed));
># 157 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h"
>struct jailhouse_setup_data {
> struct {
>  __u16 version;
>  __u16 compatible_version;
> } __attribute__((packed)) hdr;
> struct {
>  __u16 pm_timer_address;
>  __u16 num_cpus;
>  __u64 pci_mmconfig_base;
>  __u32 tsc_khz;
>  __u32 apic_khz;
>  __u8 standard_ioapic;
>  __u8 cpu_ids[255];
> } __attribute__((packed)) v1;
> struct {
>  __u32 flags;
> } __attribute__((packed)) v2;
>} __attribute__((packed));
>
>
>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;
> __u64 acpi_rsdp_addr;
> __u8 _pad3[8];
> __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[112];
> __u32 cc_blob_address;
> 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 secure_boot;
> __u8 _pad5[2];
># 215 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h"
> __u8 sentinel;
> __u8 _pad6[1];
> struct setup_header hdr;
> __u8 _pad7[0x290-0x1f1-sizeof(struct setup_header)];
> __u32 edd_mbr_sig_buffer[16];
> struct boot_e820_entry e820_table[128];
> __u8 _pad8[48];
> struct edd_info eddbuf[6];
> __u8 _pad9[276];
>} __attribute__((packed));
># 265 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/bootparam.h"
>enum x86_hardware_subarch {
> X86_SUBARCH_PC = 0,
> X86_SUBARCH_LGUEST,
> X86_SUBARCH_XEN,
> X86_SUBARCH_INTEL_MID,
> X86_SUBARCH_CE4100,
> X86_NR_SUBARCHS,
>};
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mem_encrypt.h" 2
>
>
>
>extern u64 sme_me_mask;
>extern u64 sev_status;
>
>void sme_encrypt_execute(unsigned long encrypted_kernel_vaddr,
>    unsigned long decrypted_kernel_vaddr,
>    unsigned long kernel_len,
>    unsigned long encryption_wa,
>    unsigned long encryption_pgd);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_early_encrypt(resource_size_t paddr,
>         unsigned long size);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_early_decrypt(resource_size_t paddr,
>         unsigned long size);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_map_bootdata(char *real_mode_data);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_unmap_bootdata(char *real_mode_data);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_early_init(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sev_setup_arch(void);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_encrypt_kernel(struct boot_params *bp);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sme_enable(struct boot_params *bp);
>
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) early_set_memory_decrypted(unsigned long vaddr, unsigned long size);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) early_set_memory_encrypted(unsigned long vaddr, unsigned long size);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) early_set_mem_enc_dec_hypercall(unsigned long vaddr, int npages,
>         bool enc);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) mem_encrypt_free_decrypted_mem(void);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) sev_es_init_vc_handling(void);
># 90 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mem_encrypt.h"
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) mem_encrypt_init(void);
>
>void add_encrypt_protection_map(void);
># 103 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mem_encrypt.h"
>extern char __start_bss_decrypted[], __end_bss_decrypted[], __start_bss_decrypted_unused[];
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 sme_get_me_mask(void)
>{
> return sme_me_mask;
>}
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/mem_encrypt.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_types.h" 2
># 46 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_64_types.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kaslr.h" 1
>
>
>
>
>unsigned long kaslr_get_random_long(const char *purpose);
>
>
>void kernel_randomize_memory(void);
>void init_trampoline_kaslr(void);
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_64_types.h" 2
># 47 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_types.h" 2
># 56 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_types.h"
>extern phys_addr_t physical_mask;
>
>
>
>
>
>extern int devmem_is_allowed(unsigned long pagenr);
>
>extern unsigned long max_low_pfn_mapped;
>extern unsigned long max_pfn_mapped;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) phys_addr_t get_max_mapped(void)
>{
> return (phys_addr_t)max_pfn_mapped << 12;
>}
>
>bool pfn_range_is_mapped(unsigned long start_pfn, unsigned long end_pfn);
>
>extern void initmem_init(void);
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_64.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_64.h"
>extern unsigned long max_pfn;
>extern unsigned long phys_base;
>
>extern unsigned long page_offset_base;
>extern unsigned long vmalloc_base;
>extern unsigned long vmemmap_base;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __phys_addr_nodebug(unsigned long x)
>{
> unsigned long y = x - (0xffffffff80000000UL);
>
>
> x = y + ((x > y) ? phys_base : ((0xffffffff80000000UL) - ((unsigned long)page_offset_base)));
>
> return x;
>}
># 43 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_64.h"
>void clear_page_orig(void *page);
>void clear_page_rep(void *page);
>void clear_page_erms(void *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_page(void *page)
>{
> asm __inline volatile ("# ALT: oldinstr2\n" "661:\n\t" "call %P[old]" "\n662:\n" "# ALT: padding2\n" ".skip -((" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")) > 0) * " "(" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")), 0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 3*32+16)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" " .long 661b - .\n" " .long " "664""2""f - .\n" " .word " "( 9*32+ 9)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""2""f-""664""2""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "call %P[new1]" "\n" "665""1" ":\n" "# ALT: replacement " "2" "\n" "664""2"":\n\t" "call %P[new2]" "\n" "665""2" ":\n" ".popsection\n" : "=D" (page), "+r" (current_stack_pointer) : [old] "i" (clear_page_orig), [new1] "i" (clear_page_rep), [new2] "i" (clear_page_erms), "0" (page) : "cc", "memory", "rax", "rcx")
>
>
>
>
>                                     ;
>}
>
>void copy_page(void *to, void *from);
># 78 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long task_size_max(void)
>{
> unsigned long ret;
>
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "movq %[small],%0" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "(16*32+16)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "movq %[large],%0" "\n" "665""1" ":\n" ".popsection\n" : "=r" (ret) : "i" (0), [small] "i" ((1ul << 47)-((1UL) << 12)), [large] "i" ((1ul << 56)-((1UL) << 12)))
>
>
>
>                                       ;
>
> return ret;
>}
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h" 2
>
>
>
>
>
>
>struct page;
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/range.h" 1
>
>
>
>
>
>struct range {
> u64 start;
> u64 end;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 range_len(const struct range *range)
>{
> return range->end - range->start + 1;
>}
>
>int add_range(struct range *range, int az, int nr_range,
>  u64 start, u64 end);
>
>
>int add_range_with_merge(struct range *range, int az, int nr_range,
>    u64 start, u64 end);
>
>void subtract_range(struct range *range, int az, u64 start, u64 end);
>
>int clean_sort_range(struct range *range, int az);
>
>void sort_range(struct range *range, int nr_range);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) resource_size_t cap_resource(u64 val)
>{
> if (val > ((resource_size_t)~0))
>  return ((resource_size_t)~0);
>
> return val;
>}
># 22 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h" 2
>extern struct range pfn_mapped[];
>extern int nr_pfn_mapped;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_user_page(void *page, unsigned long vaddr,
>       struct page *pg)
>{
> clear_page(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void copy_user_page(void *to, void *from, unsigned long vaddr,
>      struct page *topage)
>{
> copy_page(to, from);
>}
># 71 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h"
>extern bool __virt_addr_valid(unsigned long kaddr);
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/memory_model.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pfn.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/pfn.h"
>typedef struct {
> u64 val;
>} pfn_t;
># 6 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/memory_model.h" 2
># 77 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/getorder.h" 1
># 29 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/getorder.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__const__)) int get_order(unsigned long size)
>{
> if (__builtin_constant_p(size)) {
>  if (!size)
>   return 64 - 12;
>
>  if (size < (1UL << 12))
>   return 0;
>
>  return ( __builtin_constant_p((size) - 1) ? (((size) - 1) < 2 ? 0 : 63 - __builtin_clzll((size) - 1)) : (sizeof((size) - 1) <= 4) ? __ilog2_u32((size) - 1) : __ilog2_u64((size) - 1) ) - 12 + 1;
> }
>
> size--;
> size >>= 12;
>
>
>
> return fls64(size);
>
>}
># 78 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/page.h" 2
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h" 2
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h" 2
># 52 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h"
>struct task_struct;
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeature.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor-flags.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/processor-flags.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor-flags.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
>
>
>struct task_struct;
>struct mm_struct;
>struct io_bitmap;
>struct vm86;
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/math_emu.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/segment.h" 1
># 238 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/segment.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long vdso_encode_cpunode(int cpu, unsigned long node)
>{
> return (node << 12) | cpu;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vdso_read_cpunode(unsigned *cpu, unsigned *node)
>{
> unsigned int p;
># 255 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/segment.h"
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "lsl %[seg],%[p]" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "(16*32+22)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" ".byte 0xf3,0x0f,0xc7,0xf8" "\n" "665""1" ":\n" ".popsection\n" : [p] "=a" (p) : "i" (0), [seg] "r" ((15*8 + 3)))
>
>
>                                           ;
>
> if (cpu)
>  *cpu = (p & 0xfff);
> if (node)
>  *node = (p >> 12);
>}
># 290 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/segment.h"
>extern const char early_idt_handler_array[32][9];
>extern void early_ignore_irq(void);
>
>
>extern const char xen_early_idt_handler_array[32][8];
># 336 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/segment.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __loadsegment_fs(unsigned short value)
>{
> asm volatile("						\n"
>       "1:	movw %0, %%fs			\n"
>       "2:					\n"
>
>       " .pushsection \"__ex_table\",\"a\"\n" " .balign 4\n" " .long (" "1b" ") - .\n" " .long (" "2b" ") - .\n" " .long " "5" " \n" " .popsection\n"
>
>       : : "rm" (value) : "memory");
>}
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ptrace.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ptrace-abi.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ptrace.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h" 2
># 59 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>struct pt_regs {
>
>
>
>
> unsigned long r15;
> unsigned long r14;
> unsigned long r13;
> unsigned long r12;
> unsigned long bp;
> unsigned long bx;
>
> unsigned long r11;
> unsigned long r10;
> unsigned long r9;
> unsigned long r8;
> unsigned long ax;
> unsigned long cx;
> unsigned long dx;
> unsigned long si;
> unsigned long di;
>
>
>
>
> unsigned long orig_ax;
>
> unsigned long ip;
> unsigned long cs;
> unsigned long flags;
> unsigned long sp;
> unsigned long ss;
>
>};
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h" 1
># 38 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/desc_defs.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/desc_defs.h"
>struct desc_struct {
> u16 limit0;
> u16 base0;
> u16 base1: 8, type: 4, s: 1, dpl: 2, p: 1;
> u16 limit1: 4, avl: 1, l: 1, d: 1, g: 1, base2: 8;
>} __attribute__((packed));
># 40 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/desc_defs.h"
>enum {
> GATE_INTERRUPT = 0xE,
> GATE_TRAP = 0xF,
> GATE_CALL = 0xC,
> GATE_TASK = 0x5,
>};
>
>enum {
> DESC_TSS = 0x9,
> DESC_LDT = 0x2,
> DESCTYPE_S = 0x10,
>};
>
>
>struct ldttss_desc {
> u16 limit0;
> u16 base0;
>
> u16 base1 : 8, type : 5, dpl : 2, p : 1;
> u16 limit1 : 4, zero0 : 3, g : 1, base2 : 8;
>
> u32 base3;
> u32 zero1;
>
>} __attribute__((packed));
>
>typedef struct ldttss_desc ldt_desc;
>typedef struct ldttss_desc tss_desc;
>
>struct idt_bits {
> u16 ist : 3,
>   zero : 5,
>   type : 5,
>   dpl : 2,
>   p : 1;
>} __attribute__((packed));
>
>struct idt_data {
> unsigned int vector;
> unsigned int segment;
> struct idt_bits bits;
> const void *addr;
>};
>
>struct gate_struct {
> u16 offset_low;
> u16 segment;
> struct idt_bits bits;
> u16 offset_middle;
>
> u32 offset_high;
> u32 reserved;
>
>} __attribute__((packed));
>
>typedef struct gate_struct gate_desc;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long gate_offset(const gate_desc *g)
>{
>
> return g->offset_low | ((unsigned long)g->offset_middle << 16) |
>  ((unsigned long) g->offset_high << 32);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long gate_segment(const gate_desc *g)
>{
> return g->segment;
>}
>
>struct desc_ptr {
> unsigned short size;
> unsigned long address;
>} __attribute__((packed)) ;
># 39 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h" 1
># 141 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>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
>};
># 245 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64_types.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/sparsemem.h" 1
># 34 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/sparsemem.h"
>extern int phys_to_target_node(phys_addr_t start);
>
>extern int memory_add_physaddr_to_nid(u64 start);
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64_types.h" 2
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64_types.h"
>typedef unsigned long pteval_t;
>typedef unsigned long pmdval_t;
>typedef unsigned long pudval_t;
>typedef unsigned long p4dval_t;
>typedef unsigned long pgdval_t;
>typedef unsigned long pgprotval_t;
>
>typedef struct { pteval_t pte; } pte_t;
>
>
>extern unsigned int __pgtable_l5_enabled;
># 43 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64_types.h"
>extern unsigned int pgdir_shift;
>extern unsigned int ptrs_per_p4d;
># 246 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h" 2
># 261 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>typedef struct pgprot { pgprotval_t pgprot; } pgprot_t;
>
>typedef struct { pgdval_t pgd; } pgd_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t pgprot_nx(pgprot_t prot)
>{
> return ((pgprot_t) { (((prot).pgprot) | (((pteval_t)(1)) << 63)) } );
>}
># 294 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgd_t native_make_pgd(pgdval_t val)
>{
> return (pgd_t) { val & (~0ULL) };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgdval_t native_pgd_val(pgd_t pgd)
>{
> return pgd.pgd & (~0ULL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgdval_t pgd_flags(pgd_t pgd)
>{
> return native_pgd_val(pgd) & (~((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)));
>}
>
>
>typedef struct { p4dval_t p4d; } p4d_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4d_t native_make_p4d(pudval_t val)
>{
> return (p4d_t) { val };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4dval_t native_p4d_val(p4d_t p4d)
>{
> return p4d.p4d;
>}
># 336 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>typedef struct { pudval_t pud; } pud_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t native_make_pud(pmdval_t val)
>{
> return (pud_t) { val };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pudval_t native_pud_val(pud_t pud)
>{
> return pud.pud;
>}
># 362 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>typedef struct { pmdval_t pmd; } pmd_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t native_make_pmd(pmdval_t val)
>{
> return (pmd_t) { val };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmdval_t native_pmd_val(pmd_t pmd)
>{
> return pmd.pmd;
>}
># 387 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4dval_t p4d_pfn_mask(p4d_t p4d)
>{
>
> return ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4dval_t p4d_flags_mask(p4d_t p4d)
>{
> return ~p4d_pfn_mask(p4d);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4dval_t p4d_flags(p4d_t p4d)
>{
> return native_p4d_val(p4d) & p4d_flags_mask(p4d);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pudval_t pud_pfn_mask(pud_t pud)
>{
> if (native_pud_val(pud) & (((pteval_t)(1)) << 7))
>  return (((signed long)(~(((1UL) << 30)-1))) & physical_mask);
> else
>  return ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pudval_t pud_flags_mask(pud_t pud)
>{
> return ~pud_pfn_mask(pud);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pudval_t pud_flags(pud_t pud)
>{
> return native_pud_val(pud) & pud_flags_mask(pud);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmdval_t pmd_pfn_mask(pmd_t pmd)
>{
> if (native_pmd_val(pmd) & (((pteval_t)(1)) << 7))
>  return (((signed long)(~(((1UL) << 21)-1))) & physical_mask);
> else
>  return ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmdval_t pmd_flags_mask(pmd_t pmd)
>{
> return ~pmd_pfn_mask(pmd);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmdval_t pmd_flags(pmd_t pmd)
>{
> return native_pmd_val(pmd) & pmd_flags_mask(pmd);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t native_make_pte(pteval_t val)
>{
> return (pte_t) { .pte = val };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pteval_t native_pte_val(pte_t pte)
>{
> return pte.pte;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pteval_t pte_flags(pte_t pte)
>{
> return native_pte_val(pte) & (~((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)));
>}
># 463 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>unsigned long cachemode2protval(enum page_cache_mode pcm);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprotval_t protval_4k_2_large(pgprotval_t val)
>{
> return (val & ~((((pteval_t)(1)) << 7) | (((pteval_t)(1)) << 12))) |
>  ((val & (((pteval_t)(1)) << 7)) << (12 - 7));
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t pgprot_4k_2_large(pgprot_t pgprot)
>{
> return ((pgprot_t) { (protval_4k_2_large(((pgprot).pgprot))) } );
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprotval_t protval_large_2_4k(pgprotval_t val)
>{
> return (val & ~((((pteval_t)(1)) << 7) | (((pteval_t)(1)) << 12))) |
>  ((val & (((pteval_t)(1)) << 12)) >>
>   (12 - 7));
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t pgprot_large_2_4k(pgprot_t pgprot)
>{
> return ((pgprot_t) { (protval_large_2_4k(((pgprot).pgprot))) } );
>}
>
>
>typedef struct page *pgtable_t;
>
>extern pteval_t __supported_pte_mask;
>extern pteval_t __default_kernel_pte_mask;
>extern void set_nx(void);
>extern int nx_enabled;
>
>
>extern pgprot_t pgprot_writecombine(pgprot_t prot);
>
>
>extern pgprot_t pgprot_writethrough(pgprot_t prot);
>
>
>
>
>
>struct file;
>pgprot_t phys_mem_access_prot(struct file *file, unsigned long pfn,
>                              unsigned long size, pgprot_t vma_prot);
>
>
>void set_pte_vaddr(unsigned long vaddr, pte_t pte);
>
>
>
>
>
>
>
>struct seq_file;
>extern void arch_report_meminfo(struct seq_file *m);
>
>enum pg_level {
> PG_LEVEL_NONE,
> PG_LEVEL_4K,
> PG_LEVEL_2M,
> PG_LEVEL_1G,
> PG_LEVEL_512G,
> PG_LEVEL_NUM
>};
>
>
>extern void update_page_count(int level, unsigned long pages);
># 540 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_types.h"
>extern pte_t *lookup_address(unsigned long address, unsigned int *level);
>extern pte_t *lookup_address_in_pgd(pgd_t *pgd, unsigned long address,
>        unsigned int *level);
>
>struct mm_struct;
>extern pte_t *lookup_address_in_mm(struct mm_struct *mm, unsigned long address,
>       unsigned int *level);
>extern pmd_t *lookup_pmd_address(unsigned long address);
>extern phys_addr_t slow_virt_to_phys(void *__address);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) kernel_map_pages_in_pgd(pgd_t *pgd, u64 pfn,
>       unsigned long address,
>       unsigned numpages,
>       unsigned long page_flags);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) kernel_unmap_pages_in_pgd(pgd_t *pgd, unsigned long address,
>         unsigned long numpages);
># 40 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/static_key.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr-index.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unwind_hints.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/orc_types.h" 1
># 53 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/orc_types.h"
>struct orc_entry {
> s16 sp_offset;
> s16 bp_offset;
>
> unsigned sp_reg:4;
> unsigned bp_reg:4;
> unsigned type:2;
> unsigned end:1;
>
>
>
>
>
>
>
>} __attribute__((__packed__));
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unwind_hints.h" 2
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h" 2
># 175 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h"
>typedef u8 retpoline_thunk_t[32];
>extern retpoline_thunk_t __x86_indirect_thunk_array[];
>
>extern void __x86_return_thunk(void);
>extern void zen_untrain_ret(void);
>extern void entry_ibpb(void);
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/GEN-for-each-reg.h" 1
>
>
>
>
>
>extern retpoline_thunk_t __x86_indirect_thunk_rax;
>extern retpoline_thunk_t __x86_indirect_thunk_rcx;
>extern retpoline_thunk_t __x86_indirect_thunk_rdx;
>extern retpoline_thunk_t __x86_indirect_thunk_rbx;
>extern retpoline_thunk_t __x86_indirect_thunk_rsp;
>extern retpoline_thunk_t __x86_indirect_thunk_rbp;
>extern retpoline_thunk_t __x86_indirect_thunk_rsi;
>extern retpoline_thunk_t __x86_indirect_thunk_rdi;
>extern retpoline_thunk_t __x86_indirect_thunk_r8;
>extern retpoline_thunk_t __x86_indirect_thunk_r9;
>extern retpoline_thunk_t __x86_indirect_thunk_r10;
>extern retpoline_thunk_t __x86_indirect_thunk_r11;
>extern retpoline_thunk_t __x86_indirect_thunk_r12;
>extern retpoline_thunk_t __x86_indirect_thunk_r13;
>extern retpoline_thunk_t __x86_indirect_thunk_r14;
>extern retpoline_thunk_t __x86_indirect_thunk_r15;
># 187 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h" 2
># 244 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h"
>enum spectre_v2_mitigation {
> SPECTRE_V2_NONE,
> SPECTRE_V2_RETPOLINE,
> SPECTRE_V2_LFENCE,
> SPECTRE_V2_EIBRS,
> SPECTRE_V2_EIBRS_RETPOLINE,
> SPECTRE_V2_EIBRS_LFENCE,
> SPECTRE_V2_IBRS,
>};
>
>
>enum spectre_v2_user_mitigation {
> SPECTRE_V2_USER_NONE,
> SPECTRE_V2_USER_STRICT,
> SPECTRE_V2_USER_STRICT_PREFERRED,
> SPECTRE_V2_USER_PRCTL,
> SPECTRE_V2_USER_SECCOMP,
>};
>
>
>enum ssb_mitigation {
> SPEC_STORE_BYPASS_NONE,
> SPEC_STORE_BYPASS_DISABLE,
> SPEC_STORE_BYPASS_PRCTL,
> SPEC_STORE_BYPASS_SECCOMP,
>};
>
>extern char __indirect_thunk_start[];
>extern char __indirect_thunk_end[];
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void alternative_msr_write(unsigned int msr, u64 val, unsigned int feature)
>{
> asm volatile("# ALT: oldnstr\n" "661:\n\t" "" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "%c[feature]" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "wrmsr" "\n" "665""1" ":\n" ".popsection\n"
>  : : "c" (msr),
>      "a" ((u32)val),
>      "d" ((u32)(val >> 32)),
>      [feature] "i" (feature)
>  : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void indirect_branch_prediction_barrier(void)
>{
> u64 val = ((((1UL))) << (0));
>
> alternative_msr_write(0x00000049, val, ( 7*32+21));
>}
>
>
>extern u64 x86_spec_ctrl_base;
>extern u64 x86_spec_ctrl_current;
>extern void update_spec_ctrl_cond(u64 val);
>extern u64 spec_ctrl_current(void);
># 320 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h"
>extern struct static_key_false switch_to_cond_stibp;
>extern struct static_key_false switch_mm_cond_ibpb;
>extern struct static_key_false switch_mm_always_ibpb;
>
>extern struct static_key_false mds_user_clear;
>extern struct static_key_false mds_idle_clear;
>
>extern struct static_key_false mmio_stale_data_clear;
># 338 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void mds_clear_cpu_buffers(void)
>{
> static const u16 ds = (3*8);
># 351 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/nospec-branch.h"
> asm volatile("verw %[ds]" : : [ds] "m" (ds) : "cc");
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void mds_user_clear_cpu_buffers(void)
>{
> if (({ bool branch; if (__builtin_types_compatible_p(typeof(*&mds_user_clear), struct static_key_true)) branch = !arch_static_branch(&(&mds_user_clear)->key, true); else if (__builtin_types_compatible_p(typeof(*&mds_user_clear), struct static_key_false)) branch = !arch_static_branch_jump(&(&mds_user_clear)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }))
>  mds_clear_cpu_buffers();
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mds_idle_clear_cpu_buffers(void)
>{
> if (({ bool branch; if (__builtin_types_compatible_p(typeof(*&mds_idle_clear), struct static_key_true)) branch = !arch_static_branch(&(&mds_idle_clear)->key, true); else if (__builtin_types_compatible_p(typeof(*&mds_idle_clear), struct static_key_false)) branch = !arch_static_branch_jump(&(&mds_idle_clear)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }))
>  mds_clear_cpu_buffers();
>}
># 41 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h" 2
>
>struct page;
>struct thread_struct;
>struct desc_ptr;
>struct tss_struct;
>struct mm_struct;
>struct desc_struct;
>struct task_struct;
>struct cpumask;
>struct flush_tlb_info;
>struct mmu_gather;
>struct vm_area_struct;
>
>
>
>
>
>struct paravirt_callee_save {
> void *func;
>};
>
>
>struct pv_info {
>
> u16 extra_user_64bit_cs;
>
>
> const char *name;
>};
>
>
>struct pv_lazy_ops {
>
> void (*enter)(void);
> void (*leave)(void);
> void (*flush)(void);
>} ;
>
>
>struct pv_cpu_ops {
>
> void (*io_delay)(void);
>
>
> unsigned long (*get_debugreg)(int regno);
> void (*set_debugreg)(int regno, unsigned long value);
>
> unsigned long (*read_cr0)(void);
> void (*write_cr0)(unsigned long);
>
> void (*write_cr4)(unsigned long);
>
>
> void (*load_tr_desc)(void);
> void (*load_gdt)(const struct desc_ptr *);
> void (*load_idt)(const struct desc_ptr *);
> void (*set_ldt)(const void *desc, unsigned entries);
> unsigned long (*store_tr)(void);
> void (*load_tls)(struct thread_struct *t, unsigned int cpu);
> void (*load_gs_index)(unsigned int idx);
> void (*write_ldt_entry)(struct desc_struct *ldt, int entrynum,
>    const void *desc);
> void (*write_gdt_entry)(struct desc_struct *,
>    int entrynum, const void *desc, int size);
> void (*write_idt_entry)(gate_desc *,
>    int entrynum, const gate_desc *gate);
> void (*alloc_ldt)(struct desc_struct *ldt, unsigned entries);
> void (*free_ldt)(struct desc_struct *ldt, unsigned entries);
>
> void (*load_sp0)(unsigned long sp0);
>
>
> void (*invalidate_io_bitmap)(void);
> void (*update_io_bitmap)(void);
>
>
> void (*wbinvd)(void);
>
>
> void (*cpuid)(unsigned int *eax, unsigned int *ebx,
>        unsigned int *ecx, unsigned int *edx);
>
>
> u64 (*read_msr)(unsigned int msr);
> void (*write_msr)(unsigned int msr, unsigned low, unsigned high);
>
>
>
>
>
> u64 (*read_msr_safe)(unsigned int msr, int *err);
> int (*write_msr_safe)(unsigned int msr, unsigned low, unsigned high);
>
> u64 (*read_pmc)(int counter);
>
> void (*start_context_switch)(struct task_struct *prev);
> void (*end_context_switch)(struct task_struct *next);
>
>} ;
>
>struct pv_irq_ops {
># 150 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h"
> struct paravirt_callee_save save_fl;
> struct paravirt_callee_save irq_disable;
> struct paravirt_callee_save irq_enable;
>
> void (*safe_halt)(void);
> void (*halt)(void);
>
>} ;
>
>struct pv_mmu_ops {
>
> void (*flush_tlb_user)(void);
> void (*flush_tlb_kernel)(void);
> void (*flush_tlb_one_user)(unsigned long addr);
> void (*flush_tlb_multi)(const struct cpumask *cpus,
>    const struct flush_tlb_info *info);
>
> void (*tlb_remove_table)(struct mmu_gather *tlb, void *table);
>
>
> void (*exit_mmap)(struct mm_struct *mm);
> void (*notify_page_enc_status_changed)(unsigned long pfn, int npages, bool enc);
>
>
> struct paravirt_callee_save read_cr2;
> void (*write_cr2)(unsigned long);
>
> unsigned long (*read_cr3)(void);
> void (*write_cr3)(unsigned long);
>
>
> void (*activate_mm)(struct mm_struct *prev,
>       struct mm_struct *next);
> void (*dup_mmap)(struct mm_struct *oldmm,
>    struct mm_struct *mm);
>
>
> int (*pgd_alloc)(struct mm_struct *mm);
> void (*pgd_free)(struct mm_struct *mm, pgd_t *pgd);
>
>
>
>
>
> void (*alloc_pte)(struct mm_struct *mm, unsigned long pfn);
> void (*alloc_pmd)(struct mm_struct *mm, unsigned long pfn);
> void (*alloc_pud)(struct mm_struct *mm, unsigned long pfn);
> void (*alloc_p4d)(struct mm_struct *mm, unsigned long pfn);
> void (*release_pte)(unsigned long pfn);
> void (*release_pmd)(unsigned long pfn);
> void (*release_pud)(unsigned long pfn);
> void (*release_p4d)(unsigned long pfn);
>
>
> void (*set_pte)(pte_t *ptep, pte_t pteval);
> void (*set_pmd)(pmd_t *pmdp, pmd_t pmdval);
>
> pte_t (*ptep_modify_prot_start)(struct vm_area_struct *vma, unsigned long addr,
>     pte_t *ptep);
> void (*ptep_modify_prot_commit)(struct vm_area_struct *vma, unsigned long addr,
>     pte_t *ptep, pte_t pte);
>
> 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 *pudp, pud_t pudval);
>
> 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_p4d)(p4d_t *p4dp, p4d_t p4dval);
>
>
> struct paravirt_callee_save p4d_val;
> struct paravirt_callee_save make_p4d;
>
> void (*set_pgd)(pgd_t *pgdp, pgd_t pgdval);
>
>
> struct pv_lazy_ops lazy_mode;
>
>
>
>
>
> void (*set_fixmap)(unsigned idx,
>      phys_addr_t phys, pgprot_t flags);
>
>} ;
>
>struct arch_spinlock;
>
>
>
>
>struct qspinlock;
>
>struct pv_lock_ops {
> void (*queued_spin_lock_slowpath)(struct qspinlock *lock, u32 val);
> struct paravirt_callee_save queued_spin_unlock;
>
> void (*wait)(u8 *ptr, u8 val);
> void (*kick)(int cpu);
>
> struct paravirt_callee_save vcpu_is_preempted;
>} ;
>
>
>
>
>struct paravirt_patch_template {
> struct pv_cpu_ops cpu;
> struct pv_irq_ops irq;
> struct pv_mmu_ops mmu;
> struct pv_lock_ops lock;
>} ;
>
>extern struct pv_info pv_info;
>extern struct paravirt_patch_template pv_ops;
>extern void (*paravirt_iret)(void);
># 307 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h"
>unsigned int paravirt_patch(u8 type, void *insn_buff, unsigned long addr, unsigned int len);
>
>int paravirt_disable_iospace(void);
># 566 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt_types.h"
>enum paravirt_lazy_mode {
> PARAVIRT_LAZY_NONE,
> PARAVIRT_LAZY_MMU,
> PARAVIRT_LAZY_CPU,
>};
>
>enum paravirt_lazy_mode paravirt_get_lazy_mode(void);
>void paravirt_start_context_switch(struct task_struct *prev);
>void paravirt_end_context_switch(struct task_struct *next);
>
>void paravirt_enter_lazy_mmu(void);
>void paravirt_leave_lazy_mmu(void);
>void paravirt_flush_lazy_mmu(void);
>
>void _paravirt_nop(void);
>u64 _paravirt_ident_64(u64);
>
>
>
>
>struct paravirt_patch_site {
> u8 *instr;
> u8 type;
> u8 len;
>};
>
>extern struct paravirt_patch_site __parainstructions[],
> __parainstructions_end[];
># 98 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/proto.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ldt.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ldt.h"
>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;
># 39 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/ldt.h"
> unsigned int lm:1;
>
>};
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/proto.h" 2
>
>struct task_struct;
>
>
>
>void syscall_init(void);
>
>
>void entry_SYSCALL_64(void);
>void entry_SYSCALL_64_safe_stack(void);
>long do_arch_prctl_64(struct task_struct *task, int option, unsigned long arg2);
># 27 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/proto.h"
>void entry_SYSENTER_compat(void);
>void __end_entry_SYSENTER_compat(void);
>void entry_SYSCALL_compat(void);
>void entry_SYSCALL_compat_safe_stack(void);
>void entry_INT80_compat(void);
>
>void xen_entry_INT80_compat(void);
>
>
>
>void x86_configure_nx(void);
>void x86_report_nx(void);
>
>extern int reboot_force;
>
>long do_arch_prctl_common(struct task_struct *task, int option,
>     unsigned long arg2);
># 101 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h" 2
>
>struct cpuinfo_x86;
>struct task_struct;
>
>extern unsigned long profile_pc(struct pt_regs *regs);
>
>extern unsigned long
>convert_ip_to_linear(struct task_struct *child, struct pt_regs *regs);
>extern void send_sigtrap(struct pt_regs *regs, int error_code, int si_code);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long regs_return_value(struct pt_regs *regs)
>{
> return regs->ax;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void regs_set_return_value(struct pt_regs *regs, unsigned long rc)
>{
> regs->ax = rc;
>}
># 131 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int user_mode(struct pt_regs *regs)
>{
>
>
>
> return !!(regs->cs & 3);
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int v8086_mode(struct pt_regs *regs)
>{
>
>
>
> return 0;
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool user_64bit_mode(struct pt_regs *regs)
>{
># 160 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
> return regs->cs == (6*8 + 3) || regs->cs == pv_info.extra_user_64bit_cs;
>
>
>
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool any_64bit_mode(struct pt_regs *regs)
>{
>
> return !user_mode(regs) || user_64bit_mode(regs);
>
>
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool ip_within_syscall_gap(struct pt_regs *regs)
>{
> bool ret = (regs->ip >= (unsigned long)entry_SYSCALL_64 &&
>      regs->ip < (unsigned long)entry_SYSCALL_64_safe_stack);
>
>
> ret = ret || (regs->ip >= (unsigned long)entry_SYSCALL_compat &&
>        regs->ip < (unsigned long)entry_SYSCALL_compat_safe_stack);
>
>
> return ret;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long kernel_stack_pointer(struct pt_regs *regs)
>{
> return regs->sp;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long instruction_pointer(struct pt_regs *regs)
>{
> return regs->ip;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void instruction_pointer_set(struct pt_regs *regs,
>  unsigned long val)
>{
> regs->ip = val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long frame_pointer(struct pt_regs *regs)
>{
> return regs->bp;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long user_stack_pointer(struct pt_regs *regs)
>{
> return regs->sp;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void user_stack_pointer_set(struct pt_regs *regs,
>  unsigned long val)
>{
> regs->sp = val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool regs_irqs_disabled(struct pt_regs *regs)
>{
> return !(regs->flags & (((1UL)) << (9)));
>}
>
>
>extern int regs_query_register_offset(const char *name);
>extern const char *regs_query_register_name(unsigned int offset);
># 249 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long regs_get_register(struct pt_regs *regs,
>           unsigned int offset)
>{
> if (__builtin_expect(!!(offset > (__builtin_offsetof(struct pt_regs, ss))), 0))
>  return 0;
># 266 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
> return *(unsigned long *)((unsigned long)regs + offset);
>}
># 277 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int regs_within_kernel_stack(struct pt_regs *regs,
>        unsigned long addr)
>{
> return ((addr & ~((((1UL) << 12) << (2 + 0)) - 1)) == (regs->sp & ~((((1UL) << 12) << (2 + 0)) - 1)));
>}
># 292 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long *regs_get_kernel_stack_nth_addr(struct pt_regs *regs, unsigned int n)
>{
> unsigned long *addr = (unsigned long *)regs->sp;
>
> addr += n;
> if (regs_within_kernel_stack(regs, (unsigned long)addr))
>  return addr;
> else
>  return ((void *)0);
>}
>
>
>extern long copy_from_kernel_nofault(void *dst, const void *src, size_t size);
># 315 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long regs_get_kernel_stack_nth(struct pt_regs *regs,
>            unsigned int n)
>{
> unsigned long *addr;
> unsigned long val;
> long ret;
>
> addr = regs_get_kernel_stack_nth_addr(regs, n);
> if (addr) {
>  ret = copy_from_kernel_nofault(&val, addr, sizeof(val));
>  if (!ret)
>   return val;
> }
> return 0;
>}
># 342 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long regs_get_kernel_argument(struct pt_regs *regs,
>           unsigned int n)
>{
> static const unsigned int argument_offs[] = {
>
>
>
>
>
>
>  __builtin_offsetof(struct pt_regs, di),
>  __builtin_offsetof(struct pt_regs, si),
>  __builtin_offsetof(struct pt_regs, dx),
>  __builtin_offsetof(struct pt_regs, cx),
>  __builtin_offsetof(struct pt_regs, r8),
>  __builtin_offsetof(struct pt_regs, r9),
>
>
> };
>
> if (n >= 6) {
>  n -= 6 - 1;
>  return regs_get_kernel_stack_nth(regs, n);
> } else
>  return regs_get_register(regs, argument_offs[n]);
>}
># 378 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ptrace.h"
>struct user_desc;
>extern int do_get_thread_area(struct task_struct *p, int idx,
>         struct user_desc *info);
>extern int do_set_thread_area(struct task_struct *p, int idx,
>         struct user_desc *info, int can_allocate);
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/math_emu.h" 2
>
>
>
>
>
>struct math_emu_info {
> long ___orig_eip;
> struct pt_regs *regs;
>};
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
>struct _fpx_sw_bytes {
>
>
>
>
> __u32 magic1;
># 54 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
> __u32 extended_size;
>
>
>
>
>
> __u64 xfeatures;
>
>
>
>
>
> __u32 xstate_size;
>
>
> __u32 padding[7];
>};
># 85 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
>struct _fpreg {
> __u16 significand[4];
> __u16 exponent;
>};
>
>
>struct _fpxreg {
> __u16 significand[4];
> __u16 exponent;
> __u16 padding[3];
>};
>
>
>struct _xmmreg {
> __u32 element[4];
>};
>
>
>
>
>
>
>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;
> };
>};
># 149 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
>struct _fpstate_64 {
> __u16 cwd;
> __u16 swd;
>
> __u16 twd;
> __u16 fop;
> __u64 rip;
> __u64 rdp;
> __u32 mxcsr;
> __u32 mxcsr_mask;
> __u32 st_space[32];
> __u32 xmm_space[64];
> __u32 reserved2[12];
> union {
>  __u32 reserved3[12];
>  struct _fpx_sw_bytes sw_reserved;
> };
>};
>
>
>
>
>
>
>
>struct _header {
> __u64 xfeatures;
> __u64 reserved1[2];
> __u64 reserved2[5];
>};
>
>struct _ymmh_state {
>
> __u32 ymmh_space[64];
>};
># 192 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
>struct _xstate {
> struct _fpstate_64 fpstate;
> struct _header xstate_hdr;
> struct _ymmh_state ymmh;
>
>};
>
>
>
>
>struct sigcontext_32 {
> __u16 gs, __gsh;
> __u16 fs, __fsh;
> __u16 es, __esh;
> __u16 ds, __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, __csh;
> __u32 flags;
> __u32 sp_at_signal;
> __u16 ss, __ssh;
># 230 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
> __u32 fpstate;
> __u32 oldmask;
> __u32 cr2;
>};
>
>
>
>
>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;
># 273 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sigcontext.h"
> __u64 fpstate;
> __u64 reserved1[8];
>};
># 17 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr-index.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpumask.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/string.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h" 2
>
>extern char *strndup_user(const char *, long);
>extern void *memdup_user(const void *, size_t);
>extern void *vmemdup_user(const void *, size_t);
>extern void *memdup_user_nul(const void *, size_t);
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/string.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/string_64.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/string_64.h"
>extern void *memcpy(void *to, const void *from, size_t len);
>extern void *__memcpy(void *to, const void *from, size_t len);
>
>
>void *memset(void *s, int c, size_t n);
>void *__memset(void *s, int c, size_t n);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *memset16(uint16_t *s, uint16_t v, size_t n)
>{
> long d0, d1;
> asm volatile("rep\n\t"
>       "stosw"
>       : "=&c" (d0), "=&D" (d1)
>       : "a" (v), "1" (s), "0" (n)
>       : "memory");
> return s;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *memset32(uint32_t *s, uint32_t v, size_t n)
>{
> long d0, d1;
> asm volatile("rep\n\t"
>       "stosl"
>       : "=&c" (d0), "=&D" (d1)
>       : "a" (v), "1" (s), "0" (n)
>       : "memory");
> return s;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *memset64(uint64_t *s, uint64_t v, size_t n)
>{
> long d0, d1;
> asm volatile("rep\n\t"
>       "stosq"
>       : "=&c" (d0), "=&D" (d1)
>       : "a" (v), "1" (s), "0" (n)
>       : "memory");
> return s;
>}
>
>
>void *memmove(void *dest, const void *src, size_t count);
>void *__memmove(void *dest, const void *src, size_t count);
>
>int memcmp(const void *cs, const void *ct, size_t count);
>size_t strlen(const char *s);
>char *strcpy(char *dest, const char *src);
>char *strcat(char *dest, const char *src);
>int strcmp(const char *cs, const char *ct);
># 87 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/string_64.h"
>void __memcpy_flushcache(void *dst, const void *src, size_t cnt);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void memcpy_flushcache(void *dst, const void *src, size_t cnt)
>{
> if (__builtin_constant_p(cnt)) {
>  switch (cnt) {
>   case 4:
>    asm ("movntil %1, %0" : "=m"(*(u32 *)dst) : "r"(*(u32 *)src));
>    return;
>   case 8:
>    asm ("movntiq %1, %0" : "=m"(*(u64 *)dst) : "r"(*(u64 *)src));
>    return;
>   case 16:
>    asm ("movntiq %1, %0" : "=m"(*(u64 *)dst) : "r"(*(u64 *)src));
>    asm ("movntiq %1, %0" : "=m"(*(u64 *)(dst + 8)) : "r"(*(u64 *)(src + 8)));
>    return;
>  }
> }
> __memcpy_flushcache(dst, src, cnt);
>}
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/string.h" 2
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h" 2
>
>
>extern char * strcpy(char *,const char *);
>
>
>extern char * strncpy(char *,const char *, __kernel_size_t);
>
>
>size_t strlcpy(char *, const char *, size_t);
>
>
>ssize_t strscpy(char *, const char *, size_t);
>
>
>
>ssize_t strscpy_pad(char *dest, const char *src, size_t count);
>
>
>extern char * strcat(char *, const char *);
>
>
>extern char * strncat(char *, const char *, __kernel_size_t);
>
>
>extern size_t strlcat(char *, const char *, __kernel_size_t);
>
>
>extern int strcmp(const char *,const char *);
>
>
>extern int strncmp(const char *,const char *,__kernel_size_t);
>
>
>extern int strcasecmp(const char *s1, const char *s2);
>
>
>extern int strncasecmp(const char *s1, const char *s2, size_t n);
>
>
>extern char * strchr(const char *,int);
>
>
>extern char * strchrnul(const char *,int);
>
>extern char * strnchrnul(const char *, size_t, int);
>
>extern char * strnchr(const char *, size_t, int);
>
>
>extern char * strrchr(const char *,int);
>
>extern char * __attribute__((__warn_unused_result__)) skip_spaces(const char *);
>
>extern char *strim(char *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) char *strstrip(char *str)
>{
> return strim(str);
>}
>
>
>extern char * strstr(const char *, const char *);
>
>
>extern char * strnstr(const char *, const char *, size_t);
>
>
>extern __kernel_size_t strlen(const char *);
>
>
>extern __kernel_size_t strnlen(const char *,__kernel_size_t);
>
>
>extern char * strpbrk(const char *,const char *);
>
>
>extern char * strsep(char **,const char *);
>
>
>extern __kernel_size_t strspn(const char *,const char *);
>
>
>extern __kernel_size_t strcspn(const char *,const char *);
># 122 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *memset_l(unsigned long *p, unsigned long v,
>  __kernel_size_t n)
>{
> if (64 == 32)
>  return memset32((uint32_t *)p, v, n);
> else
>  return memset64((uint64_t *)p, v, n);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *memset_p(void **p, void *v, __kernel_size_t n)
>{
> if (64 == 32)
>  return memset32((uint32_t *)p, (uintptr_t)v, n);
> else
>  return memset64((uint64_t *)p, (uintptr_t)v, n);
>}
>
>extern void **__memcat_p(void **a, void **b);
># 153 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>extern void * memscan(void *,int,__kernel_size_t);
>
>
>extern int memcmp(const void *,const void *,__kernel_size_t);
>
>
>extern int bcmp(const void *,const void *,__kernel_size_t);
>
>
>extern void * memchr(const void *,int,__kernel_size_t);
># 171 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>void *memchr_inv(const void *s, int c, size_t n);
>char *strreplace(char *s, char old, char new);
>
>extern void kfree_const(const void *x);
>
>extern char *kstrdup(const char *s, gfp_t gfp) __attribute__((__malloc__));
>extern const char *kstrdup_const(const char *s, gfp_t gfp);
>extern char *kstrndup(const char *s, size_t len, gfp_t gfp);
>extern void *kmemdup(const void *src, size_t len, gfp_t gfp);
>extern char *kmemdup_nul(const char *s, size_t len, gfp_t gfp);
>
>extern char **argv_split(gfp_t gfp, const char *str, int *argcp);
>extern void argv_free(char **argv);
>
>extern bool sysfs_streq(const char *s1, const char *s2);
>int match_string(const char * const *array, size_t n, const char *string);
>int __sysfs_match_string(const char * const *array, size_t n, const char *s);
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>int vbin_printf(u32 *bin_buf, size_t size, const char *fmt, va_list args);
>int bstr_printf(char *buf, size_t size, const char *fmt, const u32 *bin_buf);
>int bprintf(u32 *bin_buf, size_t size, const char *fmt, ...) __attribute__((__format__(printf, 3, 4)));
>
>
>extern ssize_t memory_read_from_buffer(void *to, size_t count, loff_t *ppos,
>           const void *from, size_t available);
>
>int ptr_to_hashval(const void *ptr, unsigned long *hashval_out);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool strstarts(const char *str, const char *prefix)
>{
> return strncmp(str, prefix, strlen(prefix)) == 0;
>}
>
>size_t memweight(const void *ptr, size_t bytes);
># 235 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memzero_explicit(void *s, size_t count)
>{
> memset(s, 0, count);
> __asm__ __volatile__("": :"r"(s) :"memory");
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *kbasename(const char *path)
>{
> const char *tail = strrchr(path, '/');
> return tail ? tail + 1 : path;
>}
>
>
>
>
>void fortify_panic(const char *name) __attribute__((__noreturn__)) __attribute__((__cold__));
>void __read_overflow(void) __attribute__((__error__("detected read beyond size of object passed as 1st parameter")));
>void __read_overflow2(void) __attribute__((__error__("detected read beyond size of object passed as 2nd parameter")));
>void __read_overflow3(void) __attribute__((__error__("detected read beyond size of object passed as 3rd parameter")));
>void __write_overflow(void) __attribute__((__error__("detected write beyond size of object passed as 1st parameter")));
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fortify-string.h" 1
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/fortify-string.h"
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) char *strncpy(char *p, const char *q, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 1);
>
> if (__builtin_constant_p(size) && p_size < size)
>  __write_overflow();
> if (p_size < size)
>  fortify_panic(__func__);
> return __builtin_strncpy(p, q, size);
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) char *strcat(char *p, const char *q)
>{
> size_t p_size = __builtin_object_size(p, 1);
>
> if (p_size == (size_t)-1)
>  return __builtin_strcat(p, q);
> if (strlcat(p, q, p_size) >= p_size)
>  fortify_panic(__func__);
> return p;
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) __kernel_size_t strlen(const char *p)
>{
> __kernel_size_t ret;
> size_t p_size = __builtin_object_size(p, 1);
>
>
> if (p_size == (size_t)-1 ||
>  (__builtin_constant_p(p[p_size - 1]) && p[p_size - 1] == '\0'))
>  return __builtin_strlen(p);
> ret = strnlen(p, p_size);
> if (p_size <= ret)
>  fortify_panic(__func__);
> return ret;
>}
>
>extern __kernel_size_t __real_strnlen(const char *, __kernel_size_t) __asm__("strnlen");
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) __kernel_size_t strnlen(const char *p, __kernel_size_t maxlen)
>{
> size_t p_size = __builtin_object_size(p, 1);
> __kernel_size_t ret = __real_strnlen(p, maxlen < p_size ? maxlen : p_size);
>
> if (p_size <= ret && maxlen != ret)
>  fortify_panic(__func__);
> return ret;
>}
>
>
>extern size_t __real_strlcpy(char *, const char *, size_t) __asm__("strlcpy");
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) size_t strlcpy(char *p, const char *q, size_t size)
>{
> size_t ret;
> size_t p_size = __builtin_object_size(p, 1);
> size_t q_size = __builtin_object_size(q, 1);
>
> if (p_size == (size_t)-1 && q_size == (size_t)-1)
>  return __real_strlcpy(p, q, size);
> ret = strlen(q);
> if (size) {
>  size_t len = (ret >= size) ? size - 1 : ret;
>
>  if (__builtin_constant_p(len) && len >= p_size)
>   __write_overflow();
>  if (len >= p_size)
>   fortify_panic(__func__);
>  __builtin_memcpy(p, q, len);
>  p[len] = '\0';
> }
> return ret;
>}
>
>
>extern ssize_t __real_strscpy(char *, const char *, size_t) __asm__("strscpy");
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) ssize_t strscpy(char *p, const char *q, size_t size)
>{
> size_t len;
>
> size_t p_size = __builtin_object_size(p, 1);
> size_t q_size = __builtin_object_size(q, 1);
>
>
> if (p_size == (size_t) -1 && q_size == (size_t) -1)
>  return __real_strscpy(p, q, size);
>
>
>
>
>
> if (__builtin_constant_p(size) && size > p_size)
>  __write_overflow();
>
>
>
>
>
> len = strnlen(q, size);
>
>
>
>
>
> len = len == size ? size : len + 1;
>
>
>
>
>
> if (len > p_size)
>  fortify_panic(__func__);
>
>
>
>
>
>
> return __real_strscpy(p, q, len);
>}
>
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) char *strncat(char *p, const char *q, __kernel_size_t count)
>{
> size_t p_len, copy_len;
> size_t p_size = __builtin_object_size(p, 1);
> size_t q_size = __builtin_object_size(q, 1);
>
> if (p_size == (size_t)-1 && q_size == (size_t)-1)
>  return __builtin_strncat(p, q, count);
> p_len = strlen(p);
> copy_len = strnlen(q, count);
> if (p_size < p_len + copy_len + 1)
>  fortify_panic(__func__);
> __builtin_memcpy(p + p_len, q, copy_len);
> p[p_len + copy_len] = '\0';
> return p;
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *memset(void *p, int c, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
>
> if (__builtin_constant_p(size) && p_size < size)
>  __write_overflow();
> if (p_size < size)
>  fortify_panic(__func__);
> return __builtin_memset(p, c, size);
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *memcpy(void *p, const void *q, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
> size_t q_size = __builtin_object_size(q, 0);
>
> if (__builtin_constant_p(size)) {
>  if (p_size < size)
>   __write_overflow();
>  if (q_size < size)
>   __read_overflow2();
> }
> if (p_size < size || q_size < size)
>  fortify_panic(__func__);
> return __builtin_memcpy(p, q, size);
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *memmove(void *p, const void *q, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
> size_t q_size = __builtin_object_size(q, 0);
>
> if (__builtin_constant_p(size)) {
>  if (p_size < size)
>   __write_overflow();
>  if (q_size < size)
>   __read_overflow2();
> }
> if (p_size < size || q_size < size)
>  fortify_panic(__func__);
> return __builtin_memmove(p, q, size);
>}
>
>extern void *__real_memscan(void *, int, __kernel_size_t) __asm__("memscan");
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *memscan(void *p, int c, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
>
> if (__builtin_constant_p(size) && p_size < size)
>  __read_overflow();
> if (p_size < size)
>  fortify_panic(__func__);
> return __real_memscan(p, c, size);
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) int memcmp(const void *p, const void *q, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
> size_t q_size = __builtin_object_size(q, 0);
>
> if (__builtin_constant_p(size)) {
>  if (p_size < size)
>   __read_overflow();
>  if (q_size < size)
>   __read_overflow2();
> }
> if (p_size < size || q_size < size)
>  fortify_panic(__func__);
> return __builtin_memcmp(p, q, size);
>}
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *memchr(const void *p, int c, __kernel_size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
>
> if (__builtin_constant_p(size) && p_size < size)
>  __read_overflow();
> if (p_size < size)
>  fortify_panic(__func__);
> return __builtin_memchr(p, c, size);
>}
>
>void *__real_memchr_inv(const void *s, int c, size_t n) __asm__("memchr_inv");
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *memchr_inv(const void *p, int c, size_t size)
>{
> size_t p_size = __builtin_object_size(p, 0);
>
> if (__builtin_constant_p(size) && p_size < size)
>  __read_overflow();
> if (p_size < size)
>  fortify_panic(__func__);
> return __real_memchr_inv(p, c, size);
>}
>
>extern void *__real_kmemdup(const void *src, size_t len, gfp_t gfp) __asm__("kmemdup");
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) void *kmemdup(const void *p, size_t size, gfp_t gfp)
>{
> size_t p_size = __builtin_object_size(p, 0);
>
> if (__builtin_constant_p(size) && p_size < size)
>  __read_overflow();
> if (p_size < size)
>  fortify_panic(__func__);
> return __real_kmemdup(p, size, gfp);
>}
>
>
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((gnu_inline)) char *strcpy(char *p, const char *q)
>{
> size_t p_size = __builtin_object_size(p, 1);
> size_t q_size = __builtin_object_size(q, 1);
> size_t size;
>
> if (p_size == (size_t)-1 && q_size == (size_t)-1)
>  return __builtin_strcpy(p, q);
> size = strlen(q) + 1;
>
> if (__builtin_constant_p(size) && p_size < size)
>  __write_overflow();
>
> if (p_size < size)
>  fortify_panic(__func__);
> memcpy(p, q, size);
> return p;
>}
># 263 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h" 2
># 273 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcpy_and_pad(void *dest, size_t dest_len,
>      const void *src, size_t count, int pad)
>{
> if (dest_len > count) {
>  memcpy(dest, src, count);
>  memset(dest + count, pad, dest_len - count);
> } else
>  memcpy(dest, src, dest_len);
>}
># 333 "/usr/src/linux-5.14.21-150500.53/include/linux/string.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) size_t str_has_prefix(const char *str, const char *prefix)
>{
> size_t len = strlen(prefix);
> return strncmp(str, prefix, len) == 0 ? len : 0;
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h" 2
>
>
>struct device;
># 124 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>unsigned long *bitmap_alloc(unsigned int nbits, gfp_t flags);
>unsigned long *bitmap_zalloc(unsigned int nbits, gfp_t flags);
>unsigned long *bitmap_alloc_node(unsigned int nbits, gfp_t flags, int node);
>unsigned long *bitmap_zalloc_node(unsigned int nbits, gfp_t flags, int node);
>void bitmap_free(const unsigned long *bitmap);
>
>
>unsigned long *devm_bitmap_alloc(struct device *dev,
>     unsigned int nbits, gfp_t flags);
>unsigned long *devm_bitmap_zalloc(struct device *dev,
>      unsigned int nbits, gfp_t flags);
>
>
>
>
>
>bool __bitmap_equal(const unsigned long *bitmap1,
>      const unsigned long *bitmap2, unsigned int nbits);
>bool __attribute__((__pure__)) __bitmap_or_equal(const unsigned long *src1,
>         const unsigned long *src2,
>         const unsigned long *src3,
>         unsigned int nbits);
>void __bitmap_complement(unsigned long *dst, const unsigned long *src,
>    unsigned int nbits);
>void __bitmap_shift_right(unsigned long *dst, const unsigned long *src,
>     unsigned int shift, unsigned int nbits);
>void __bitmap_shift_left(unsigned long *dst, const unsigned long *src,
>    unsigned int shift, unsigned int nbits);
>void bitmap_cut(unsigned long *dst, const unsigned long *src,
>  unsigned int first, unsigned int cut, unsigned int nbits);
>int __bitmap_and(unsigned long *dst, const unsigned long *bitmap1,
>   const unsigned long *bitmap2, unsigned int nbits);
>void __bitmap_or(unsigned long *dst, const unsigned long *bitmap1,
>   const unsigned long *bitmap2, unsigned int nbits);
>void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
>    const unsigned long *bitmap2, unsigned int nbits);
>int __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
>      const unsigned long *bitmap2, unsigned int nbits);
>void __bitmap_replace(unsigned long *dst,
>        const unsigned long *old, const unsigned long *new,
>        const unsigned long *mask, unsigned int nbits);
>bool __bitmap_intersects(const unsigned long *bitmap1,
>    const unsigned long *bitmap2, unsigned int nbits);
>bool __bitmap_subset(const unsigned long *bitmap1,
>       const unsigned long *bitmap2, unsigned int nbits);
>unsigned long __bitmap_weight(const unsigned long *bitmap, unsigned int nbits);
>void __bitmap_set(unsigned long *map, unsigned int start, int len);
>void __bitmap_clear(unsigned long *map, unsigned int start, int len);
>
>unsigned long bitmap_find_next_zero_area_off(unsigned long *map,
>          unsigned long size,
>          unsigned long start,
>          unsigned int nr,
>          unsigned long align_mask,
>          unsigned long align_offset);
># 192 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>bitmap_find_next_zero_area(unsigned long *map,
>      unsigned long size,
>      unsigned long start,
>      unsigned int nr,
>      unsigned long align_mask)
>{
> return bitmap_find_next_zero_area_off(map, size, start, nr,
>           align_mask, 0);
>}
>
>int bitmap_parse(const char *buf, unsigned int buflen,
>   unsigned long *dst, int nbits);
>int bitmap_parse_user(const char *ubuf, unsigned int ulen,
>   unsigned long *dst, int nbits);
>int bitmap_parselist(const char *buf, unsigned long *maskp,
>   int nmaskbits);
>int bitmap_parselist_user(const char *ubuf, unsigned int ulen,
>   unsigned long *dst, int nbits);
>void bitmap_remap(unsigned long *dst, const unsigned long *src,
>  const unsigned long *old, const unsigned long *new, unsigned int nbits);
>int bitmap_bitremap(int oldbit,
>  const unsigned long *old, const unsigned long *new, int bits);
>void bitmap_onto(unsigned long *dst, const unsigned long *orig,
>  const unsigned long *relmap, unsigned int bits);
>void bitmap_fold(unsigned long *dst, const unsigned long *orig,
>  unsigned int sz, unsigned int nbits);
>int bitmap_find_free_region(unsigned long *bitmap, unsigned int bits, int order);
>void bitmap_release_region(unsigned long *bitmap, unsigned int pos, int order);
>int bitmap_allocate_region(unsigned long *bitmap, unsigned int pos, int order);
>
>
>
>
>
>
>unsigned int bitmap_ord_to_pos(const unsigned long *bitmap, unsigned int ord, unsigned int nbits);
>int bitmap_print_to_pagebuf(bool list, char *buf,
>       const unsigned long *maskp, int nmaskbits);
>
>extern int bitmap_print_bitmask_to_buf(char *buf, const unsigned long *maskp,
>          int nmaskbits, loff_t off, size_t count);
>
>extern int bitmap_print_list_to_buf(char *buf, const unsigned long *maskp,
>          int nmaskbits, loff_t off, size_t count);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_zero(unsigned long *dst, unsigned int nbits)
>{
> unsigned int len = (((nbits) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(unsigned long);
> memset(dst, 0, len);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_fill(unsigned long *dst, unsigned int nbits)
>{
> unsigned int len = (((nbits) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(unsigned long);
> memset(dst, 0xff, len);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_copy(unsigned long *dst, const unsigned long *src,
>   unsigned int nbits)
>{
> unsigned int len = (((nbits) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(unsigned long);
> memcpy(dst, src, len);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_copy_clear_tail(unsigned long *dst,
>  const unsigned long *src, unsigned int nbits)
>{
> bitmap_copy(dst, src, nbits);
> if (nbits % 64)
>  dst[nbits / 64] &= (~0UL >> (-(nbits) & (64 - 1)));
>}
>
>
>
>
>
>
>void bitmap_from_arr32(unsigned long *bitmap, const u32 *buf,
>       unsigned int nbits);
>void bitmap_to_arr32(u32 *buf, const unsigned long *bitmap,
>       unsigned int nbits);
># 289 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int bitmap_and(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return (*dst = *src1 & *src2 & (~0UL >> (-(nbits) & (64 - 1)))) != 0;
> return __bitmap_and(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_or(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  *dst = *src1 | *src2;
> else
>  __bitmap_or(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_xor(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  *dst = *src1 ^ *src2;
> else
>  __bitmap_xor(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int bitmap_andnot(unsigned long *dst, const unsigned long *src1,
>   const unsigned long *src2, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return (*dst = *src1 & ~(*src2) & (~0UL >> (-(nbits) & (64 - 1)))) != 0;
> return __bitmap_andnot(dst, src1, src2, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_complement(unsigned long *dst, const unsigned long *src,
>   unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  *dst = ~(*src);
> else
>  __bitmap_complement(dst, src, nbits);
>}
># 339 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bitmap_equal(const unsigned long *src1,
>    const unsigned long *src2, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return !((*src1 ^ *src2) & (~0UL >> (-(nbits) & (64 - 1))));
> if (__builtin_constant_p(nbits & (8 - 1)) &&
>     (((nbits) & ((typeof(nbits))(8) - 1)) == 0))
>  return !memcmp(src1, src2, nbits / 8);
> return __bitmap_equal(src1, src2, nbits);
>}
># 359 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bitmap_or_equal(const unsigned long *src1,
>       const unsigned long *src2,
>       const unsigned long *src3,
>       unsigned int nbits)
>{
> if (!(__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return __bitmap_or_equal(src1, src2, src3, nbits);
>
> return !(((*src1 | *src2) ^ *src3) & (~0UL >> (-(nbits) & (64 - 1))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bitmap_intersects(const unsigned long *src1,
>         const unsigned long *src2,
>         unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return ((*src1 & *src2) & (~0UL >> (-(nbits) & (64 - 1)))) != 0;
> else
>  return __bitmap_intersects(src1, src2, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bitmap_subset(const unsigned long *src1,
>     const unsigned long *src2, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return ! ((*src1 & ~(*src2)) & (~0UL >> (-(nbits) & (64 - 1))));
> else
>  return __bitmap_subset(src1, src2, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bitmap_empty(const unsigned long *src, unsigned nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return ! (*src & (~0UL >> (-(nbits) & (64 - 1))));
>
> return find_first_bit(src, nbits) == nbits;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bitmap_full(const unsigned long *src, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return ! (~(*src) & (~0UL >> (-(nbits) & (64 - 1))));
>
> return find_first_zero_bit(src, nbits) == nbits;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>unsigned long bitmap_weight(const unsigned long *src, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  return hweight_long(*src & (~0UL >> (-(nbits) & (64 - 1))));
> return __bitmap_weight(src, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void bitmap_set(unsigned long *map, unsigned int start,
>  unsigned int nbits)
>{
> if (__builtin_constant_p(nbits) && nbits == 1)
>  __set_bit(start, map);
> else if (__builtin_constant_p(start & (8 - 1)) &&
>   (((start) & ((typeof(start))(8) - 1)) == 0) &&
>   __builtin_constant_p(nbits & (8 - 1)) &&
>   (((nbits) & ((typeof(nbits))(8) - 1)) == 0))
>  memset((char *)map + start / 8, 0xff, nbits / 8);
> else
>  __bitmap_set(map, start, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void bitmap_clear(unsigned long *map, unsigned int start,
>  unsigned int nbits)
>{
> if (__builtin_constant_p(nbits) && nbits == 1)
>  __clear_bit(start, map);
> else if (__builtin_constant_p(start & (8 - 1)) &&
>   (((start) & ((typeof(start))(8) - 1)) == 0) &&
>   __builtin_constant_p(nbits & (8 - 1)) &&
>   (((nbits) & ((typeof(nbits))(8) - 1)) == 0))
>  memset((char *)map + start / 8, 0, nbits / 8);
> else
>  __bitmap_clear(map, start, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_shift_right(unsigned long *dst, const unsigned long *src,
>    unsigned int shift, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  *dst = (*src & (~0UL >> (-(nbits) & (64 - 1)))) >> shift;
> else
>  __bitmap_shift_right(dst, src, shift, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_shift_left(unsigned long *dst, const unsigned long *src,
>    unsigned int shift, unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  *dst = (*src << shift) & (~0UL >> (-(nbits) & (64 - 1)));
> else
>  __bitmap_shift_left(dst, src, shift, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_replace(unsigned long *dst,
>      const unsigned long *old,
>      const unsigned long *new,
>      const unsigned long *mask,
>      unsigned int nbits)
>{
> if ((__builtin_constant_p(nbits) && (nbits) <= 64 && (nbits) > 0))
>  *dst = (*old & ~(*mask)) | (*new & *mask);
> else
>  __bitmap_replace(dst, old, new, mask, nbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_next_clear_region(unsigned long *bitmap,
>         unsigned int *rs, unsigned int *re,
>         unsigned int end)
>{
> *rs = find_next_zero_bit(bitmap, end, *rs);
> *re = find_next_bit(bitmap, end, *rs + 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_next_set_region(unsigned long *bitmap,
>       unsigned int *rs, unsigned int *re,
>       unsigned int end)
>{
> *rs = find_next_bit(bitmap, end, *rs);
> *re = find_next_zero_bit(bitmap, end, *rs + 1);
>}
># 549 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_from_u64(unsigned long *dst, u64 mask)
>{
> dst[0] = mask & (~0UL);
>
> if (sizeof(mask) > sizeof(unsigned long))
>  dst[1] = mask >> 32;
>}
># 565 "/usr/src/linux-5.14.21-150500.53/include/linux/bitmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long bitmap_get_value8(const unsigned long *map,
>           unsigned long start)
>{
> const size_t index = ((start) / 64);
> const unsigned long offset = start % 64;
>
> return (map[index] >> offset) & 0xFF;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bitmap_set_value8(unsigned long *map, unsigned long value,
>         unsigned long start)
>{
> const size_t index = ((start) / 64);
> const unsigned long offset = start % 64;
>
> map[index] &= ~(0xFFUL << offset);
> map[index] |= value << offset;
>}
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cmpxchg.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cmpxchg.h"
>extern void __xchg_wrong_size(void)
> __attribute__((__error__("Bad argument size for xchg")));
>extern void __cmpxchg_wrong_size(void)
> __attribute__((__error__("Bad argument size for cmpxchg")));
>extern void __xadd_wrong_size(void)
> __attribute__((__error__("Bad argument size for xadd")));
>extern void __add_wrong_size(void)
> __attribute__((__error__("Bad argument size for add")));
># 145 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cmpxchg.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cmpxchg_64.h" 1
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_64bit(volatile u64 *ptr, u64 val)
>{
> *ptr = val;
>}
># 146 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cmpxchg.h" 2
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_read(const atomic_t *v)
>{
>
>
>
>
> return (*(const volatile typeof( _Generic(((v)->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((v)->counter))) *)&((v)->counter));
>}
># 39 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_set(atomic_t *v, int i)
>{
> do { *(volatile typeof(v->counter) *)&(v->counter) = (i); } while (0);
>}
># 51 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_add(int i, atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "addl %1,%0"
>       : "+m" (v->counter)
>       : "ir" (i) : "memory");
>}
># 65 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_sub(int i, atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "subl %1,%0"
>       : "+m" (v->counter)
>       : "ir" (i) : "memory");
>}
># 81 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_atomic_sub_and_test(int i, atomic_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "subl" " %[val], " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (v->counter), "=@cc" "e" (c) : [val] "er" (i) : "memory"); c; });
>}
># 93 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_inc(atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "incl %0"
>       : "+m" (v->counter) :: "memory");
>}
># 106 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_dec(atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "decl %0"
>       : "+m" (v->counter) :: "memory");
>}
># 121 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_atomic_dec_and_test(atomic_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "decl" " " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (v->counter), "=@cc" "e" (c) : : "memory"); c; });
>}
># 135 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_atomic_inc_and_test(atomic_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "incl" " " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (v->counter), "=@cc" "e" (c) : : "memory"); c; });
>}
># 150 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_atomic_add_negative(int i, atomic_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "addl" " %[val], " "%[var]" "\n\t/* output condition code " "s" "*/\n" : [var] "+m" (v->counter), "=@cc" "s" (c) : [val] "er" (i) : "memory"); c; });
>}
># 163 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_add_return(int i, atomic_t *v)
>{
> return i + ({ __typeof__ (*(((&v->counter)))) __ret = (((i))); switch (sizeof(*(((&v->counter))))) { case 1: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "b %b0, %1\n" : "+q" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 2: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "w %w0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 4: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "l %0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 8: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "q %q0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; default: __xadd_wrong_size(); } __ret; });
>}
># 176 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_sub_return(int i, atomic_t *v)
>{
> return arch_atomic_add_return(-i, v);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_fetch_add(int i, atomic_t *v)
>{
> return ({ __typeof__ (*(((&v->counter)))) __ret = (((i))); switch (sizeof(*(((&v->counter))))) { case 1: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "b %b0, %1\n" : "+q" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 2: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "w %w0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 4: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "l %0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 8: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "q %q0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; default: __xadd_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_fetch_sub(int i, atomic_t *v)
>{
> return ({ __typeof__ (*(((&v->counter)))) __ret = (((-i))); switch (sizeof(*(((&v->counter))))) { case 1: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "b %b0, %1\n" : "+q" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 2: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "w %w0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 4: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "l %0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 8: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "q %q0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; default: __xadd_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_cmpxchg(atomic_t *v, int old, int new)
>{
> return ({ __typeof__(*((&v->counter))) __ret; __typeof__(*((&v->counter))) __old = ((old)); __typeof__(*((&v->counter))) __new = ((new)); switch ((sizeof(*(&v->counter)))) { case 1: { volatile u8 *__ptr = (volatile u8 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgb %2,%1" : "=a" (__ret), "+m" (*__ptr) : "q" (__new), "0" (__old) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgw %2,%1" : "=a" (__ret), "+m" (*__ptr) : "r" (__new), "0" (__old) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgl %2,%1" : "=a" (__ret), "+m" (*__ptr) : "r" (__new), "0" (__old) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgq %2,%1" : "=a" (__ret), "+m" (*__ptr) : "r" (__new), "0" (__old) : "memory"); break; } default: __cmpxchg_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_atomic_try_cmpxchg(atomic_t *v, int *old, int new)
>{
> return ({ bool success; __typeof__(((&v->counter))) _old = (__typeof__(((&v->counter))))(((old))); __typeof__(*(((&v->counter)))) __old = *_old; __typeof__(*(((&v->counter)))) __new = (((new))); switch ((sizeof(*(&v->counter)))) { case 1: { volatile u8 *__ptr = (volatile u8 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgb %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "q" (__new) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgw %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgl %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgq %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } default: __cmpxchg_wrong_size(); } if (__builtin_expect(!!(!success), 0)) *_old = __old; __builtin_expect(!!(success), 1); });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_xchg(atomic_t *v, int new)
>{
> return ({ __typeof__ (*((&v->counter))) __ret = ((new)); switch (sizeof(*((&v->counter)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_and(int i, atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "andl %1,%0"
>   : "+m" (v->counter)
>   : "ir" (i)
>   : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_fetch_and(int i, atomic_t *v)
>{
> int val = arch_atomic_read(v);
>
> do { } while (!arch_atomic_try_cmpxchg(v, &val, val & i));
>
> return val;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_or(int i, atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "orl %1,%0"
>   : "+m" (v->counter)
>   : "ir" (i)
>   : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_fetch_or(int i, atomic_t *v)
>{
> int val = arch_atomic_read(v);
>
> do { } while (!arch_atomic_try_cmpxchg(v, &val, val | i));
>
> return val;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic_xor(int i, atomic_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xorl %1,%0"
>   : "+m" (v->counter)
>   : "ir" (i)
>   : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_atomic_fetch_xor(int i, atomic_t *v)
>{
> int val = arch_atomic_read(v);
>
> do { } while (!arch_atomic_try_cmpxchg(v, &val, val ^ i));
>
> return val;
>}
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_read(const atomic64_t *v)
>{
> return (*(const volatile typeof( _Generic(((v)->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((v)->counter))) *)&((v)->counter));
>}
># 32 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_atomic64_set(atomic64_t *v, s64 i)
>{
> do { *(volatile typeof(v->counter) *)&(v->counter) = (i); } while (0);
>}
># 44 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic64_add(s64 i, atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "addq %1,%0"
>       : "=m" (v->counter)
>       : "er" (i), "m" (v->counter) : "memory");
>}
># 58 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_atomic64_sub(s64 i, atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "subq %1,%0"
>       : "=m" (v->counter)
>       : "er" (i), "m" (v->counter) : "memory");
>}
># 74 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_atomic64_sub_and_test(s64 i, atomic64_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "subq" " %[val], " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (v->counter), "=@cc" "e" (c) : [val] "er" (i) : "memory"); c; });
>}
># 86 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic64_inc(atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "incq %0"
>       : "=m" (v->counter)
>       : "m" (v->counter) : "memory");
>}
># 100 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_atomic64_dec(atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "decq %0"
>       : "=m" (v->counter)
>       : "m" (v->counter) : "memory");
>}
># 116 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_atomic64_dec_and_test(atomic64_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "decq" " " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (v->counter), "=@cc" "e" (c) : : "memory"); c; });
>}
># 130 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_atomic64_inc_and_test(atomic64_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "incq" " " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (v->counter), "=@cc" "e" (c) : : "memory"); c; });
>}
># 145 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_atomic64_add_negative(s64 i, atomic64_t *v)
>{
> return ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "addq" " %[val], " "%[var]" "\n\t/* output condition code " "s" "*/\n" : [var] "+m" (v->counter), "=@cc" "s" (c) : [val] "er" (i) : "memory"); c; });
>}
># 158 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic64_64.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64 arch_atomic64_add_return(s64 i, atomic64_t *v)
>{
> return i + ({ __typeof__ (*(((&v->counter)))) __ret = (((i))); switch (sizeof(*(((&v->counter))))) { case 1: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "b %b0, %1\n" : "+q" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 2: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "w %w0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 4: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "l %0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 8: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "q %q0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; default: __xadd_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_sub_return(s64 i, atomic64_t *v)
>{
> return arch_atomic64_add_return(-i, v);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_fetch_add(s64 i, atomic64_t *v)
>{
> return ({ __typeof__ (*(((&v->counter)))) __ret = (((i))); switch (sizeof(*(((&v->counter))))) { case 1: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "b %b0, %1\n" : "+q" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 2: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "w %w0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 4: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "l %0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 8: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "q %q0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; default: __xadd_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_fetch_sub(s64 i, atomic64_t *v)
>{
> return ({ __typeof__ (*(((&v->counter)))) __ret = (((-i))); switch (sizeof(*(((&v->counter))))) { case 1: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "b %b0, %1\n" : "+q" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 2: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "w %w0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 4: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "l %0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; case 8: asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xadd" "q %q0, %1\n" : "+r" (__ret), "+m" (*(((&v->counter)))) : : "memory", "cc"); break; default: __xadd_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)
>{
> return ({ __typeof__(*((&v->counter))) __ret; __typeof__(*((&v->counter))) __old = ((old)); __typeof__(*((&v->counter))) __new = ((new)); switch ((sizeof(*(&v->counter)))) { case 1: { volatile u8 *__ptr = (volatile u8 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgb %2,%1" : "=a" (__ret), "+m" (*__ptr) : "q" (__new), "0" (__old) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgw %2,%1" : "=a" (__ret), "+m" (*__ptr) : "r" (__new), "0" (__old) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgl %2,%1" : "=a" (__ret), "+m" (*__ptr) : "r" (__new), "0" (__old) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)((&v->counter)); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgq %2,%1" : "=a" (__ret), "+m" (*__ptr) : "r" (__new), "0" (__old) : "memory"); break; } default: __cmpxchg_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)
>{
> return ({ bool success; __typeof__(((&v->counter))) _old = (__typeof__(((&v->counter))))(((old))); __typeof__(*(((&v->counter)))) __old = *_old; __typeof__(*(((&v->counter)))) __new = (((new))); switch ((sizeof(*(&v->counter)))) { case 1: { volatile u8 *__ptr = (volatile u8 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgb %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "q" (__new) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgw %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgl %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)(((&v->counter))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgq %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } default: __cmpxchg_wrong_size(); } if (__builtin_expect(!!(!success), 0)) *_old = __old; __builtin_expect(!!(success), 1); });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_xchg(atomic64_t *v, s64 new)
>{
> return ({ __typeof__ (*((&v->counter))) __ret = ((new)); switch (sizeof(*((&v->counter)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((&v->counter))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_atomic64_and(s64 i, atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "andq %1,%0"
>   : "+m" (v->counter)
>   : "er" (i)
>   : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_fetch_and(s64 i, atomic64_t *v)
>{
> s64 val = arch_atomic64_read(v);
>
> do {
> } while (!arch_atomic64_try_cmpxchg(v, &val, val & i));
> return val;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_atomic64_or(s64 i, atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "orq %1,%0"
>   : "+m" (v->counter)
>   : "er" (i)
>   : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_fetch_or(s64 i, atomic64_t *v)
>{
> s64 val = arch_atomic64_read(v);
>
> do {
> } while (!arch_atomic64_try_cmpxchg(v, &val, val | i));
> return val;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_atomic64_xor(s64 i, atomic64_t *v)
>{
> asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "xorq %1,%0"
>   : "+m" (v->counter)
>   : "er" (i)
>   : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 arch_atomic64_fetch_xor(s64 i, atomic64_t *v)
>{
> s64 val = arch_atomic64_read(v);
>
> do {
> } while (!arch_atomic64_try_cmpxchg(v, &val, val ^ i));
> return val;
>}
># 270 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/atomic.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic.h" 2
># 80 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h" 1
># 151 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_read_acquire(const atomic_t *v)
>{
> int ret;
>
> if ((sizeof(atomic_t) == sizeof(char) || sizeof(atomic_t) == sizeof(short) || sizeof(atomic_t) == sizeof(int) || sizeof(atomic_t) == sizeof(long))) {
>  ret = ({ typeof(*&(v)->counter) ___p1 = ({ do { extern void __compiletime_assert_27(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_27(); } while (0); (*(const volatile typeof( _Generic((*&(v)->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&(v)->counter))) *)&(*&(v)->counter)); }); do { extern void __compiletime_assert_28(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_28(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
> } else {
>  ret = arch_atomic_read(v);
>  do { } while (0);
> }
>
> return ret;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_set_release(atomic_t *v, int i)
>{
> if ((sizeof(atomic_t) == sizeof(char) || sizeof(atomic_t) == sizeof(short) || sizeof(atomic_t) == sizeof(int) || sizeof(atomic_t) == sizeof(long))) {
>  do { do { extern void __compiletime_assert_29(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_29(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_30(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_30(); } while (0); do { *(volatile typeof(*&(v)->counter) *)&(*&(v)->counter) = (i); } while (0); } while (0); } while (0);
> } else {
>  do { } while (0);
>  arch_atomic_set(v, i);
> }
>}
># 367 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_inc_return(atomic_t *v)
>{
> return arch_atomic_add_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_inc_return_acquire(atomic_t *v)
>{
> return arch_atomic_add_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_inc_return_release(atomic_t *v)
>{
> return arch_atomic_add_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_inc_return_relaxed(atomic_t *v)
>{
> return arch_atomic_add_return(1, v);
>}
># 448 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_inc(atomic_t *v)
>{
> return arch_atomic_fetch_add(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_inc_acquire(atomic_t *v)
>{
> return arch_atomic_fetch_add(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_inc_release(atomic_t *v)
>{
> return arch_atomic_fetch_add(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_inc_relaxed(atomic_t *v)
>{
> return arch_atomic_fetch_add(1, v);
>}
># 538 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_dec_return(atomic_t *v)
>{
> return arch_atomic_sub_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_dec_return_acquire(atomic_t *v)
>{
> return arch_atomic_sub_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_dec_return_release(atomic_t *v)
>{
> return arch_atomic_sub_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_dec_return_relaxed(atomic_t *v)
>{
> return arch_atomic_sub_return(1, v);
>}
># 619 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_dec(atomic_t *v)
>{
> return arch_atomic_fetch_sub(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_dec_acquire(atomic_t *v)
>{
> return arch_atomic_fetch_sub(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_dec_release(atomic_t *v)
>{
> return arch_atomic_fetch_sub(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_dec_relaxed(atomic_t *v)
>{
> return arch_atomic_fetch_sub(1, v);
>}
># 735 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_andnot(int i, atomic_t *v)
>{
> arch_atomic_and(~i, v);
>}
># 751 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_andnot(int i, atomic_t *v)
>{
> return arch_atomic_fetch_and(~i, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_andnot_acquire(int i, atomic_t *v)
>{
> return arch_atomic_fetch_and(~i, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_andnot_release(int i, atomic_t *v)
>{
> return arch_atomic_fetch_and(~i, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_andnot_relaxed(int i, atomic_t *v)
>{
> return arch_atomic_fetch_and(~i, v);
>}
># 1169 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_fetch_add_unless(atomic_t *v, int a, int u)
>{
> int c = arch_atomic_read(v);
>
> do {
>  if (__builtin_expect(!!(c == u), 0))
>   break;
> } while (!arch_atomic_try_cmpxchg(v, &c, c + a));
>
> return c;
>}
># 1194 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_add_unless(atomic_t *v, int a, int u)
>{
> return arch_atomic_fetch_add_unless(v, a, u) != u;
>}
># 1210 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_inc_not_zero(atomic_t *v)
>{
> return arch_atomic_add_unless(v, 1, 0);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_inc_unless_negative(atomic_t *v)
>{
> int c = arch_atomic_read(v);
>
> do {
>  if (__builtin_expect(!!(c < 0), 0))
>   return false;
> } while (!arch_atomic_try_cmpxchg(v, &c, c + 1));
>
> return true;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_dec_unless_positive(atomic_t *v)
>{
> int c = arch_atomic_read(v);
>
> do {
>  if (__builtin_expect(!!(c > 0), 0))
>   return false;
> } while (!arch_atomic_try_cmpxchg(v, &c, c - 1));
>
> return true;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>arch_atomic_dec_if_positive(atomic_t *v)
>{
> int dec, c = arch_atomic_read(v);
>
> do {
>  dec = c - 1;
>  if (__builtin_expect(!!(dec < 0), 0))
>   break;
> } while (!arch_atomic_try_cmpxchg(v, &c, dec));
>
> return dec;
>}
># 1272 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_read_acquire(const atomic64_t *v)
>{
> s64 ret;
>
> if ((sizeof(atomic64_t) == sizeof(char) || sizeof(atomic64_t) == sizeof(short) || sizeof(atomic64_t) == sizeof(int) || sizeof(atomic64_t) == sizeof(long))) {
>  ret = ({ typeof(*&(v)->counter) ___p1 = ({ do { extern void __compiletime_assert_31(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_31(); } while (0); (*(const volatile typeof( _Generic((*&(v)->counter), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&(v)->counter))) *)&(*&(v)->counter)); }); do { extern void __compiletime_assert_32(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_32(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
> } else {
>  ret = arch_atomic64_read(v);
>  do { } while (0);
> }
>
> return ret;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic64_set_release(atomic64_t *v, s64 i)
>{
> if ((sizeof(atomic64_t) == sizeof(char) || sizeof(atomic64_t) == sizeof(short) || sizeof(atomic64_t) == sizeof(int) || sizeof(atomic64_t) == sizeof(long))) {
>  do { do { extern void __compiletime_assert_33(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)))) __compiletime_assert_33(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_34(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(v)->counter) == sizeof(char) || sizeof(*&(v)->counter) == sizeof(short) || sizeof(*&(v)->counter) == sizeof(int) || sizeof(*&(v)->counter) == sizeof(long)) || sizeof(*&(v)->counter) == sizeof(long long))) __compiletime_assert_34(); } while (0); do { *(volatile typeof(*&(v)->counter) *)&(*&(v)->counter) = (i); } while (0); } while (0); } while (0);
> } else {
>  do { } while (0);
>  arch_atomic64_set(v, i);
> }
>}
># 1488 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_inc_return(atomic64_t *v)
>{
> return arch_atomic64_add_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_inc_return_acquire(atomic64_t *v)
>{
> return arch_atomic64_add_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_inc_return_release(atomic64_t *v)
>{
> return arch_atomic64_add_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_inc_return_relaxed(atomic64_t *v)
>{
> return arch_atomic64_add_return(1, v);
>}
># 1569 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_inc(atomic64_t *v)
>{
> return arch_atomic64_fetch_add(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_inc_acquire(atomic64_t *v)
>{
> return arch_atomic64_fetch_add(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_inc_release(atomic64_t *v)
>{
> return arch_atomic64_fetch_add(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_inc_relaxed(atomic64_t *v)
>{
> return arch_atomic64_fetch_add(1, v);
>}
># 1659 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_dec_return(atomic64_t *v)
>{
> return arch_atomic64_sub_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_dec_return_acquire(atomic64_t *v)
>{
> return arch_atomic64_sub_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_dec_return_release(atomic64_t *v)
>{
> return arch_atomic64_sub_return(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_dec_return_relaxed(atomic64_t *v)
>{
> return arch_atomic64_sub_return(1, v);
>}
># 1740 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_dec(atomic64_t *v)
>{
> return arch_atomic64_fetch_sub(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_dec_acquire(atomic64_t *v)
>{
> return arch_atomic64_fetch_sub(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_dec_release(atomic64_t *v)
>{
> return arch_atomic64_fetch_sub(1, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_dec_relaxed(atomic64_t *v)
>{
> return arch_atomic64_fetch_sub(1, v);
>}
># 1856 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic64_andnot(s64 i, atomic64_t *v)
>{
> arch_atomic64_and(~i, v);
>}
># 1872 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_andnot(s64 i, atomic64_t *v)
>{
> return arch_atomic64_fetch_and(~i, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)
>{
> return arch_atomic64_fetch_and(~i, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_andnot_release(s64 i, atomic64_t *v)
>{
> return arch_atomic64_fetch_and(~i, v);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)
>{
> return arch_atomic64_fetch_and(~i, v);
>}
># 2290 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)
>{
> s64 c = arch_atomic64_read(v);
>
> do {
>  if (__builtin_expect(!!(c == u), 0))
>   break;
> } while (!arch_atomic64_try_cmpxchg(v, &c, c + a));
>
> return c;
>}
># 2315 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic64_add_unless(atomic64_t *v, s64 a, s64 u)
>{
> return arch_atomic64_fetch_add_unless(v, a, u) != u;
>}
># 2331 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-arch-fallback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic64_inc_not_zero(atomic64_t *v)
>{
> return arch_atomic64_add_unless(v, 1, 0);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic64_inc_unless_negative(atomic64_t *v)
>{
> s64 c = arch_atomic64_read(v);
>
> do {
>  if (__builtin_expect(!!(c < 0), 0))
>   return false;
> } while (!arch_atomic64_try_cmpxchg(v, &c, c + 1));
>
> return true;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic64_dec_unless_positive(atomic64_t *v)
>{
> s64 c = arch_atomic64_read(v);
>
> do {
>  if (__builtin_expect(!!(c > 0), 0))
>   return false;
> } while (!arch_atomic64_try_cmpxchg(v, &c, c - 1));
>
> return true;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>arch_atomic64_dec_if_positive(atomic64_t *v)
>{
> s64 dec, c = arch_atomic64_read(v);
>
> do {
>  dec = c - 1;
>  if (__builtin_expect(!!(dec < 0), 0))
>   break;
> } while (!arch_atomic64_try_cmpxchg(v, &c, dec));
>
> return dec;
>}
># 81 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-long.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-long.h"
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-long.h" 2
>
>
>typedef atomic64_t atomic_long_t;
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-long.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_read(const atomic_long_t *v)
>{
> return arch_atomic64_read(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_read_acquire(const atomic_long_t *v)
>{
> return arch_atomic64_read_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_set(atomic_long_t *v, long i)
>{
> arch_atomic64_set(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_set_release(atomic_long_t *v, long i)
>{
> arch_atomic64_set_release(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_add(long i, atomic_long_t *v)
>{
> arch_atomic64_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_add_return(long i, atomic_long_t *v)
>{
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_add_return_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_add_return_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_add_return_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_add(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_add_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_add_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_sub(long i, atomic_long_t *v)
>{
> arch_atomic64_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_sub_return(long i, atomic_long_t *v)
>{
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_sub_return_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_sub_return_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_sub_return_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_sub(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_sub_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_inc(atomic_long_t *v)
>{
> arch_atomic64_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_inc_return(atomic_long_t *v)
>{
> return arch_atomic64_inc_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_inc_return_acquire(atomic_long_t *v)
>{
> return arch_atomic64_inc_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_inc_return_release(atomic_long_t *v)
>{
> return arch_atomic64_inc_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_inc_return_relaxed(atomic_long_t *v)
>{
> return arch_atomic64_inc_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_inc(atomic_long_t *v)
>{
> return arch_atomic64_fetch_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_inc_acquire(atomic_long_t *v)
>{
> return arch_atomic64_fetch_inc_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_inc_release(atomic_long_t *v)
>{
> return arch_atomic64_fetch_inc_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_inc_relaxed(atomic_long_t *v)
>{
> return arch_atomic64_fetch_inc_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_dec(atomic_long_t *v)
>{
> arch_atomic64_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_dec_return(atomic_long_t *v)
>{
> return arch_atomic64_dec_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_dec_return_acquire(atomic_long_t *v)
>{
> return arch_atomic64_dec_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_dec_return_release(atomic_long_t *v)
>{
> return arch_atomic64_dec_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_dec_return_relaxed(atomic_long_t *v)
>{
> return arch_atomic64_dec_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_dec(atomic_long_t *v)
>{
> return arch_atomic64_fetch_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_dec_acquire(atomic_long_t *v)
>{
> return arch_atomic64_fetch_dec_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_dec_release(atomic_long_t *v)
>{
> return arch_atomic64_fetch_dec_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_dec_relaxed(atomic_long_t *v)
>{
> return arch_atomic64_fetch_dec_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_and(long i, atomic_long_t *v)
>{
> arch_atomic64_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_and(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_and_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_and_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_andnot(long i, atomic_long_t *v)
>{
> arch_atomic64_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_andnot(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_andnot_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_andnot_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_andnot_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_andnot_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_or(long i, atomic_long_t *v)
>{
> arch_atomic64_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_or(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_or_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_or_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>arch_atomic_long_xor(long i, atomic_long_t *v)
>{
> arch_atomic64_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_xor(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_xor_release(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)
>{
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_xchg(atomic_long_t *v, long i)
>{
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_xchg_acquire(atomic_long_t *v, long i)
>{
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_xchg_release(atomic_long_t *v, long i)
>{
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_xchg_relaxed(atomic_long_t *v, long i)
>{
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_cmpxchg(atomic_long_t *v, long old, long new)
>{
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)
>{
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)
>{
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)
>{
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)
>{
> return arch_atomic64_try_cmpxchg(v, (s64 *)old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)
>{
> return arch_atomic64_try_cmpxchg(v, (s64 *)old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)
>{
> return arch_atomic64_try_cmpxchg(v, (s64 *)old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)
>{
> return arch_atomic64_try_cmpxchg(v, (s64 *)old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_sub_and_test(long i, atomic_long_t *v)
>{
> return arch_atomic64_sub_and_test(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_dec_and_test(atomic_long_t *v)
>{
> return arch_atomic64_dec_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_inc_and_test(atomic_long_t *v)
>{
> return arch_atomic64_inc_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_add_negative(long i, atomic_long_t *v)
>{
> return arch_atomic64_add_negative(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)
>{
> return arch_atomic64_fetch_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_add_unless(atomic_long_t *v, long a, long u)
>{
> return arch_atomic64_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_inc_not_zero(atomic_long_t *v)
>{
> return arch_atomic64_inc_not_zero(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_inc_unless_negative(atomic_long_t *v)
>{
> return arch_atomic64_inc_unless_negative(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>arch_atomic_long_dec_unless_positive(atomic_long_t *v)
>{
> return arch_atomic64_dec_unless_positive(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>arch_atomic_long_dec_if_positive(atomic_long_t *v)
>{
> return arch_atomic64_dec_if_positive(v);
>}
># 82 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-instrumented.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic/atomic-instrumented.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_read(const atomic_t *v)
>{
> instrument_atomic_read(v, sizeof(*v));
> return arch_atomic_read(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_read_acquire(const atomic_t *v)
>{
> instrument_atomic_read(v, sizeof(*v));
> return arch_atomic_read_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_set(atomic_t *v, int i)
>{
> instrument_atomic_write(v, sizeof(*v));
> arch_atomic_set(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_set_release(atomic_t *v, int i)
>{
> instrument_atomic_write(v, sizeof(*v));
> arch_atomic_set_release(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_add(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_add_return(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_add_return_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_add_return_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_add_return_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_add(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_add_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_add_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_add_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_sub(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_sub_return(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_sub_return_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_sub_return_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_sub_return_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_sub(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_sub_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_sub_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_sub_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_inc(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_inc_return(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_inc_return_acquire(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_inc_return_release(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_inc_return_relaxed(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_inc(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_inc_acquire(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_inc_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_inc_release(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_inc_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_inc_relaxed(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_inc_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_dec(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_dec_return(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_dec_return_acquire(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_dec_return_release(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_dec_return_relaxed(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_dec(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_dec_acquire(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_dec_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_dec_release(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_dec_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_dec_relaxed(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_dec_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_and(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_and(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_and_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_and_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_and_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_andnot(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_andnot(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_andnot_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_andnot_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_andnot_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_andnot_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_andnot_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_andnot_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_or(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_or(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_or_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_or_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_or_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_xor(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_xor(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_xor_acquire(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_xor_release(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_xor_relaxed(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_xchg(atomic_t *v, int i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_xchg_acquire(atomic_t *v, int i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_xchg_release(atomic_t *v, int i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_xchg_relaxed(atomic_t *v, int i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_cmpxchg(atomic_t *v, int old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_cmpxchg_acquire(atomic_t *v, int old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_cmpxchg_release(atomic_t *v, int old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_cmpxchg_relaxed(atomic_t *v, int old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_try_cmpxchg(atomic_t *v, int *old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_try_cmpxchg_acquire(atomic_t *v, int *old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_try_cmpxchg_release(atomic_t *v, int *old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_try_cmpxchg_relaxed(atomic_t *v, int *old, int new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_sub_and_test(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_sub_and_test(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_dec_and_test(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_inc_and_test(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_add_negative(int i, atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_add_negative(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_fetch_add_unless(atomic_t *v, int a, int u)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_fetch_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_add_unless(atomic_t *v, int a, int u)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_inc_not_zero(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_not_zero(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_inc_unless_negative(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_inc_unless_negative(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_dec_unless_positive(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_unless_positive(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int
>atomic_dec_if_positive(atomic_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_dec_if_positive(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_read(const atomic64_t *v)
>{
> instrument_atomic_read(v, sizeof(*v));
> return arch_atomic64_read(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_read_acquire(const atomic64_t *v)
>{
> instrument_atomic_read(v, sizeof(*v));
> return arch_atomic64_read_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_set(atomic64_t *v, s64 i)
>{
> instrument_atomic_write(v, sizeof(*v));
> arch_atomic64_set(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_set_release(atomic64_t *v, s64 i)
>{
> instrument_atomic_write(v, sizeof(*v));
> arch_atomic64_set_release(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_add(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_add_return(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_add_return_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_add_return_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_add_return_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_add(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_add_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_add_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_add_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_sub(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_sub_return(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_sub_return_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_sub_return_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_sub_return_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_sub(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_sub_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_sub_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_sub_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_inc(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_inc_return(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_inc_return_acquire(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_inc_return_release(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_inc_return_relaxed(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_inc(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_inc_acquire(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_inc_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_inc_release(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_inc_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_inc_relaxed(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_inc_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_dec(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_dec_return(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_dec_return_acquire(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_dec_return_release(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_dec_return_relaxed(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_dec(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_dec_acquire(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_dec_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_dec_release(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_dec_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_dec_relaxed(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_dec_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_and(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_and(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_and_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_and_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_and_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_andnot(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_andnot(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_andnot_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_andnot_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_andnot_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_andnot_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_andnot_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_andnot_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_or(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_or(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_or_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_or_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_or_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic64_xor(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic64_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_xor(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_xor_acquire(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_xor_release(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_xor_relaxed(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_xchg(atomic64_t *v, s64 i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_xchg_acquire(atomic64_t *v, s64 i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_xchg_release(atomic64_t *v, s64 i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_xchg_relaxed(atomic64_t *v, s64 i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_cmpxchg(atomic64_t *v, s64 old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_cmpxchg_acquire(atomic64_t *v, s64 old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_cmpxchg_release(atomic64_t *v, s64 old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_cmpxchg_relaxed(atomic64_t *v, s64 old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_try_cmpxchg(atomic64_t *v, s64 *old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic64_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_try_cmpxchg_acquire(atomic64_t *v, s64 *old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic64_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_try_cmpxchg_release(atomic64_t *v, s64 *old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic64_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_try_cmpxchg_relaxed(atomic64_t *v, s64 *old, s64 new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic64_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_sub_and_test(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_sub_and_test(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_dec_and_test(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_inc_and_test(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_add_negative(s64 i, atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_add_negative(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_fetch_add_unless(atomic64_t *v, s64 a, s64 u)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_fetch_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_add_unless(atomic64_t *v, s64 a, s64 u)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_inc_not_zero(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_not_zero(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_inc_unless_negative(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_inc_unless_negative(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic64_dec_unless_positive(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_unless_positive(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) s64
>atomic64_dec_if_positive(atomic64_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic64_dec_if_positive(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_read(const atomic_long_t *v)
>{
> instrument_atomic_read(v, sizeof(*v));
> return arch_atomic_long_read(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_read_acquire(const atomic_long_t *v)
>{
> instrument_atomic_read(v, sizeof(*v));
> return arch_atomic_long_read_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_set(atomic_long_t *v, long i)
>{
> instrument_atomic_write(v, sizeof(*v));
> arch_atomic_long_set(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_set_release(atomic_long_t *v, long i)
>{
> instrument_atomic_write(v, sizeof(*v));
> arch_atomic_long_set_release(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_add(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_add_return(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_add_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_add_return_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_add_return_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_add_return_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_add_return_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_add_return_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_add_return_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_add(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_add(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_add_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_add_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_add_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_add_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_add_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_add_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_sub(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_sub_return(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_sub_return(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_sub_return_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_sub_return_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_sub_return_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_sub_return_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_sub_return_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_sub_return_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_sub(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_sub(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_sub_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_sub_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_sub_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_sub_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_sub_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_sub_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_inc(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_inc_return(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_inc_return_acquire(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_inc_return_release(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_inc_return_relaxed(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_inc(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_inc(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_inc_acquire(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_inc_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_inc_release(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_inc_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_inc_relaxed(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_inc_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_dec(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_dec_return(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_return(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_dec_return_acquire(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_return_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_dec_return_release(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_return_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_dec_return_relaxed(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_return_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_dec(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_dec(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_dec_acquire(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_dec_acquire(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_dec_release(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_dec_release(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_dec_relaxed(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_dec_relaxed(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_and(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_and(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_and(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_and_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_and_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_and_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_and_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_and_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_and_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_andnot(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_andnot(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_andnot(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_andnot_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_andnot_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_andnot_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_andnot_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_andnot_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_andnot_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_or(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_or(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_or(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_or_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_or_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_or_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_or_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_or_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_or_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>atomic_long_xor(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> arch_atomic_long_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_xor(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_xor(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_xor_acquire(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_xor_acquire(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_xor_release(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_xor_release(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_xor_relaxed(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_xor_relaxed(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_xchg(atomic_long_t *v, long i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_xchg(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_xchg_acquire(atomic_long_t *v, long i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_xchg_acquire(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_xchg_release(atomic_long_t *v, long i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_xchg_release(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_xchg_relaxed(atomic_long_t *v, long i)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_xchg_relaxed(v, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_cmpxchg(atomic_long_t *v, long old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_cmpxchg_acquire(atomic_long_t *v, long old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_cmpxchg_acquire(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_cmpxchg_release(atomic_long_t *v, long old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_cmpxchg_release(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_cmpxchg_relaxed(atomic_long_t *v, long old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_cmpxchg_relaxed(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_try_cmpxchg(atomic_long_t *v, long *old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_long_try_cmpxchg(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_try_cmpxchg_acquire(atomic_long_t *v, long *old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_long_try_cmpxchg_acquire(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_try_cmpxchg_release(atomic_long_t *v, long *old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_long_try_cmpxchg_release(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_try_cmpxchg_relaxed(atomic_long_t *v, long *old, long new)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> instrument_atomic_read_write(old, sizeof(*old));
> return arch_atomic_long_try_cmpxchg_relaxed(v, old, new);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_sub_and_test(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_sub_and_test(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_dec_and_test(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_inc_and_test(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_and_test(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_add_negative(long i, atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_add_negative(i, v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_fetch_add_unless(atomic_long_t *v, long a, long u)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_fetch_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_add_unless(atomic_long_t *v, long a, long u)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_add_unless(v, a, u);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_inc_not_zero(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_not_zero(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_inc_unless_negative(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_inc_unless_negative(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool
>atomic_long_dec_unless_positive(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_unless_positive(v);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>atomic_long_dec_if_positive(atomic_long_t *v)
>{
> instrument_atomic_read_write(v, sizeof(*v));
> return arch_atomic_long_dec_if_positive(v);
>}
># 83 "/usr/src/linux-5.14.21-150500.53/include/linux/atomic.h" 2
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h" 2
>
>
>
>typedef struct cpumask { unsigned long bits[(((8192) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))]; } cpumask_t;
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>extern unsigned int nr_cpu_ids;
># 90 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>extern struct cpumask __cpu_possible_mask;
>extern struct cpumask __cpu_online_mask;
>extern struct cpumask __cpu_present_mask;
>extern struct cpumask __cpu_active_mask;
>extern struct cpumask __cpu_dying_mask;
>
>
>
>
>
>
>extern atomic_t __num_online_cpus;
>
>extern cpumask_t cpus_booted_once_mask;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpu_max_bits_warn(unsigned int cpu, unsigned int bits)
>{
>
>
>
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpumask_check(unsigned int cpu)
>{
> cpu_max_bits_warn(cpu, nr_cpu_ids);
> return cpu;
>}
># 193 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpumask_first(const struct cpumask *srcp)
>{
> return find_first_bit(((srcp)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpumask_last(const struct cpumask *srcp)
>{
> return find_last_bit(((srcp)->bits), nr_cpu_ids);
>}
>
>unsigned int __attribute__((__pure__)) cpumask_next(int n, const struct cpumask *srcp);
># 218 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpumask_next_zero(int n, const struct cpumask *srcp)
>{
>
> if (n != -1)
>  cpumask_check(n);
> return find_next_zero_bit(((srcp)->bits), nr_cpu_ids, n+1);
>}
>
>int __attribute__((__pure__)) cpumask_next_and(int n, const struct cpumask *, const struct cpumask *);
>int __attribute__((__pure__)) cpumask_any_but(const struct cpumask *mask, unsigned int cpu);
>unsigned int cpumask_local_spread(unsigned int i, int node);
>int cpumask_any_and_distribute(const struct cpumask *src1p,
>          const struct cpumask *src2p);
>int cpumask_any_distribute(const struct cpumask *srcp);
># 257 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>extern int cpumask_next_wrap(int n, const struct cpumask *mask, int start, bool wrap);
># 309 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
>{
> set_bit(cpumask_check(cpu), ((dstp)->bits));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __cpumask_set_cpu(unsigned int cpu, struct cpumask *dstp)
>{
> __set_bit(cpumask_check(cpu), ((dstp)->bits));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_clear_cpu(int cpu, struct cpumask *dstp)
>{
> clear_bit(cpumask_check(cpu), ((dstp)->bits));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __cpumask_clear_cpu(int cpu, struct cpumask *dstp)
>{
> __clear_bit(cpumask_check(cpu), ((dstp)->bits));
>}
># 342 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_test_cpu(int cpu, const struct cpumask *cpumask)
>{
> return test_bit(cpumask_check(cpu), (((cpumask))->bits));
>}
># 356 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_test_and_set_cpu(int cpu, struct cpumask *cpumask)
>{
> return test_and_set_bit(cpumask_check(cpu), ((cpumask)->bits));
>}
># 370 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_test_and_clear_cpu(int cpu, struct cpumask *cpumask)
>{
> return test_and_clear_bit(cpumask_check(cpu), ((cpumask)->bits));
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_setall(struct cpumask *dstp)
>{
> bitmap_fill(((dstp)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_clear(struct cpumask *dstp)
>{
> bitmap_zero(((dstp)->bits), nr_cpu_ids);
>}
># 401 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_and(struct cpumask *dstp,
>          const struct cpumask *src1p,
>          const struct cpumask *src2p)
>{
> return bitmap_and(((dstp)->bits), ((src1p)->bits),
>           ((src2p)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_or(struct cpumask *dstp, const struct cpumask *src1p,
>         const struct cpumask *src2p)
>{
> bitmap_or(((dstp)->bits), ((src1p)->bits),
>          ((src2p)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_xor(struct cpumask *dstp,
>          const struct cpumask *src1p,
>          const struct cpumask *src2p)
>{
> bitmap_xor(((dstp)->bits), ((src1p)->bits),
>           ((src2p)->bits), nr_cpu_ids);
>}
># 444 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_andnot(struct cpumask *dstp,
>      const struct cpumask *src1p,
>      const struct cpumask *src2p)
>{
> return bitmap_andnot(((dstp)->bits), ((src1p)->bits),
>       ((src2p)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_complement(struct cpumask *dstp,
>          const struct cpumask *srcp)
>{
> bitmap_complement(((dstp)->bits), ((srcp)->bits),
>           nr_cpu_ids);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpumask_equal(const struct cpumask *src1p,
>    const struct cpumask *src2p)
>{
> return bitmap_equal(((src1p)->bits), ((src2p)->bits),
>       nr_cpu_ids);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpumask_or_equal(const struct cpumask *src1p,
>        const struct cpumask *src2p,
>        const struct cpumask *src3p)
>{
> return bitmap_or_equal(((src1p)->bits), ((src2p)->bits),
>          ((src3p)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpumask_intersects(const struct cpumask *src1p,
>         const struct cpumask *src2p)
>{
> return bitmap_intersects(((src1p)->bits), ((src2p)->bits),
>            nr_cpu_ids);
>}
># 509 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_subset(const struct cpumask *src1p,
>     const struct cpumask *src2p)
>{
> return bitmap_subset(((src1p)->bits), ((src2p)->bits),
>        nr_cpu_ids);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpumask_empty(const struct cpumask *srcp)
>{
> return bitmap_empty(((srcp)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpumask_full(const struct cpumask *srcp)
>{
> return bitmap_full(((srcp)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpumask_weight(const struct cpumask *srcp)
>{
> return bitmap_weight(((srcp)->bits), nr_cpu_ids);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_shift_right(struct cpumask *dstp,
>           const struct cpumask *srcp, int n)
>{
> bitmap_shift_right(((dstp)->bits), ((srcp)->bits), n,
>            nr_cpu_ids);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_shift_left(struct cpumask *dstp,
>          const struct cpumask *srcp, int n)
>{
> bitmap_shift_left(((dstp)->bits), ((srcp)->bits), n,
>           nr_cpu_ids);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpumask_copy(struct cpumask *dstp,
>    const struct cpumask *srcp)
>{
> bitmap_copy(((dstp)->bits), ((srcp)->bits), nr_cpu_ids);
>}
># 620 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_parse_user(const char *buf, int len,
>         struct cpumask *dstp)
>{
> return bitmap_parse_user(buf, len, ((dstp)->bits), nr_cpu_ids);
>}
># 634 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_parselist_user(const char *buf, int len,
>         struct cpumask *dstp)
>{
> return bitmap_parselist_user(buf, len, ((dstp)->bits),
>         nr_cpu_ids);
>}
># 648 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpumask_parse(const char *buf, struct cpumask *dstp)
>{
> return bitmap_parse(buf, (~0U), ((dstp)->bits), nr_cpu_ids);
>}
># 660 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpulist_parse(const char *buf, struct cpumask *dstp)
>{
> return bitmap_parselist(buf, ((dstp)->bits), nr_cpu_ids);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpumask_size(void)
>{
> return (((nr_cpu_ids) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8))) * sizeof(long);
>}
># 714 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>typedef struct cpumask *cpumask_var_t;
>
>
>
>
>bool alloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);
>bool alloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
>bool zalloc_cpumask_var_node(cpumask_var_t *mask, gfp_t flags, int node);
>bool zalloc_cpumask_var(cpumask_var_t *mask, gfp_t flags);
>void alloc_bootmem_cpumask_var(cpumask_var_t *mask);
>void free_cpumask_var(cpumask_var_t mask);
>void free_bootmem_cpumask_var(cpumask_var_t mask);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpumask_available(cpumask_var_t mask)
>{
> return mask != ((void *)0);
>}
># 782 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>extern const unsigned long cpu_all_bits[(((8192) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];
># 793 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>void init_cpu_present(const struct cpumask *src);
>void init_cpu_possible(const struct cpumask *src);
>void init_cpu_online(const struct cpumask *src);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void reset_cpu_possible_mask(void)
>{
> bitmap_zero(((&__cpu_possible_mask)->bits), 8192);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>set_cpu_possible(unsigned int cpu, bool possible)
>{
> if (possible)
>  cpumask_set_cpu(cpu, &__cpu_possible_mask);
> else
>  cpumask_clear_cpu(cpu, &__cpu_possible_mask);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>set_cpu_present(unsigned int cpu, bool present)
>{
> if (present)
>  cpumask_set_cpu(cpu, &__cpu_present_mask);
> else
>  cpumask_clear_cpu(cpu, &__cpu_present_mask);
>}
>
>void set_cpu_online(unsigned int cpu, bool online);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>set_cpu_active(unsigned int cpu, bool active)
>{
> if (active)
>  cpumask_set_cpu(cpu, &__cpu_active_mask);
> else
>  cpumask_clear_cpu(cpu, &__cpu_active_mask);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>set_cpu_dying(unsigned int cpu, bool dying)
>{
> if (dying)
>  cpumask_set_cpu(cpu, &__cpu_dying_mask);
> else
>  cpumask_clear_cpu(cpu, &__cpu_dying_mask);
>}
># 854 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __check_is_bitmap(const unsigned long *bitmap)
>{
> return 1;
>}
># 866 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>extern const unsigned long
> cpu_bit_bitmap[64 +1][(((8192) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cpumask *get_cpu_mask(unsigned int cpu)
>{
> const unsigned long *p = cpu_bit_bitmap[1 + cpu % 64];
> p -= cpu / 64;
> return ((struct cpumask *)(1 ? (p) : (void *)sizeof(__check_is_bitmap(p))));
>}
># 885 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int num_online_cpus(void)
>{
> return atomic_read(&__num_online_cpus);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_online(unsigned int cpu)
>{
> return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_online_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_possible(unsigned int cpu)
>{
> return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_possible_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_present(unsigned int cpu)
>{
> return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_present_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_active(unsigned int cpu)
>{
> return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_active_mask));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_dying(unsigned int cpu)
>{
> return cpumask_test_cpu(cpu, ((const struct cpumask *)&__cpu_dying_mask));
>}
># 979 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t
>cpumap_print_to_pagebuf(bool list, char *buf, const struct cpumask *mask)
>{
> return bitmap_print_to_pagebuf(list, buf, ((mask)->bits),
>          nr_cpu_ids);
>}
># 1002 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t
>cpumap_print_bitmask_to_buf(char *buf, const struct cpumask *mask,
>  loff_t off, size_t count)
>{
> return bitmap_print_bitmask_to_buf(buf, ((mask)->bits),
>       nr_cpu_ids, off, count) - 1;
>}
># 1017 "/usr/src/linux-5.14.21-150500.53/include/linux/cpumask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t
>cpumap_print_list_to_buf(char *buf, const struct cpumask *mask,
>  loff_t off, size_t count)
>{
> return bitmap_print_list_to_buf(buf, ((mask)->bits),
>       nr_cpu_ids, off, count) - 1;
>}
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpumask.h" 2
>
>extern cpumask_var_t cpu_callin_mask;
>extern cpumask_var_t cpu_callout_mask;
>extern cpumask_var_t cpu_initialized_mask;
>extern cpumask_var_t cpu_sibling_setup_mask;
>
>extern void setup_cpu_local_masks(void);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool arch_cpu_online(int cpu)
>{
> return (__builtin_constant_p((cpu)) ? constant_test_bit((cpu), (((((const struct cpumask *)&__cpu_online_mask))->bits))) : variable_test_bit((cpu), (((((const struct cpumask *)&__cpu_online_mask))->bits))));
>}
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/msr.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/shared/msr.h" 1
>
>
>
>
>struct msr {
> union {
>  struct {
>   u32 l;
>   u32 h;
>  };
>  u64 q;
> };
>};
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
>
>struct msr_info {
> u32 msr_no;
> struct msr reg;
> struct msr *msrs;
> int err;
>};
>
>struct msr_regs_info {
> u32 *regs;
> int err;
>};
>
>struct saved_msr {
> bool valid;
> struct msr_info info;
>};
>
>struct saved_msrs {
> unsigned int num;
> struct saved_msr *array;
>};
># 58 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/tracepoint-defs.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/tracepoint-defs.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/static_key.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/tracepoint-defs.h" 2
>
>struct static_call_key;
>
>struct trace_print_flags {
> unsigned long mask;
> const char *name;
>};
>
>struct trace_print_flags_u64 {
> unsigned long long mask;
> const char *name;
>};
>
>struct tracepoint_func {
> void *func;
> void *data;
> int prio;
>};
>
>struct tracepoint {
> const char *name;
> struct static_key key;
> struct static_call_key *static_call_key;
> void *static_call_tramp;
> void *iterator;
> int (*regfunc)(void);
> void (*unregfunc)(void);
> struct tracepoint_func *funcs;
>};
>
>
>typedef const int tracepoint_ptr_t;
>
>
>
>
>struct bpf_raw_event_map {
> struct tracepoint *tp;
> void *bpf_func;
> u32 num_args;
> u32 writable_size;
>} __attribute__((__aligned__(32)));
># 59 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
>
>
>extern struct tracepoint __tracepoint_read_msr;
>extern struct tracepoint __tracepoint_write_msr;
>extern struct tracepoint __tracepoint_rdpmc;
>extern void do_trace_write_msr(unsigned int msr, u64 val, int failed);
>extern void do_trace_read_msr(unsigned int msr, u64 val, int failed);
>extern void do_trace_rdpmc(unsigned int msr, u64 val, int failed);
># 80 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long long __rdmsr(unsigned int msr)
>{
> unsigned long low, high;
>
> asm volatile("1: rdmsr\n"
>       "2:\n"
>       " .pushsection \"__ex_table\",\"a\"\n" " .balign 4\n" " .long (" "1b" ") - .\n" " .long (" "2b" ") - .\n" " .long " "8" " \n" " .popsection\n"
>       : "=a" (low), "=d" (high) : "c" (msr));
>
> return ((low) | (high) << 32);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __wrmsr(unsigned int msr, u32 low, u32 high)
>{
> asm volatile("1: wrmsr\n"
>       "2:\n"
>       " .pushsection \"__ex_table\",\"a\"\n" " .balign 4\n" " .long (" "1b" ") - .\n" " .long (" "2b" ") - .\n" " .long " "7" " \n" " .popsection\n"
>       : : "c" (msr), "a"(low), "d" (high) : "memory");
>}
># 114 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long long native_read_msr(unsigned int msr)
>{
> unsigned long long val;
>
> val = __rdmsr(msr);
>
> if (static_key_false(&(__tracepoint_read_msr).key))
>  do_trace_read_msr(msr, val, 0);
>
> return val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long long native_read_msr_safe(unsigned int msr,
>            int *err)
>{
> unsigned long low, high;
>
> asm volatile("2: rdmsr ; xor %[err],%[err]\n"
>       "1:\n\t"
>       ".section .fixup,\"ax\"\n\t"
>       "3: mov %[fault],%[err]\n\t"
>       "xorl %%eax, %%eax\n\t"
>       "xorl %%edx, %%edx\n\t"
>       "jmp 1b\n\t"
>       ".previous\n\t"
>       " .pushsection \"__ex_table\",\"a\"\n" " .balign 4\n" " .long (" "2b" ") - .\n" " .long (" "3b" ") - .\n" " .long " "1" " \n" " .popsection\n"
>       : [err] "=r" (*err), "=a" (low), "=d" (high)
>       : "c" (msr), [fault] "i" (-5));
> if (static_key_false(&(__tracepoint_read_msr).key))
>  do_trace_read_msr(msr, ((low) | (high) << 32), *err);
> return ((low) | (high) << 32);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __attribute__((no_instrument_function))
>native_write_msr(unsigned int msr, u32 low, u32 high)
>{
> __wrmsr(msr, low, high);
>
> if (static_key_false(&(__tracepoint_write_msr).key))
>  do_trace_write_msr(msr, ((u64)high << 32 | low), 0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((no_instrument_function))
>native_write_msr_safe(unsigned int msr, u32 low, u32 high)
>{
> int err;
>
> asm volatile("2: wrmsr ; xor %[err],%[err]\n"
>       "1:\n\t"
>       ".section .fixup,\"ax\"\n\t"
>       "3:  mov %[fault],%[err] ; jmp 1b\n\t"
>       ".previous\n\t"
>       " .pushsection \"__ex_table\",\"a\"\n" " .balign 4\n" " .long (" "2b" ") - .\n" " .long (" "3b" ") - .\n" " .long " "1" " \n" " .popsection\n"
>       : [err] "=a" (err)
>       : "c" (msr), "0" (low), "d" (high),
>         [fault] "i" (-5)
>       : "memory");
> if (static_key_false(&(__tracepoint_write_msr).key))
>  do_trace_write_msr(msr, ((u64)high << 32 | low), err);
> return err;
>}
>
>extern int rdmsr_safe_regs(u32 regs[8]);
>extern int wrmsr_safe_regs(u32 regs[8]);
># 190 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long long rdtsc(void)
>{
> unsigned long low, high;
>
> asm volatile("rdtsc" : "=a" (low), "=d" (high));
>
> return ((low) | (high) << 32);
>}
># 207 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long long rdtsc_ordered(void)
>{
> unsigned long low, high;
># 225 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
> asm volatile("# ALT: oldinstr2\n" "661:\n\t" "rdtsc" "\n662:\n" "# ALT: padding2\n" ".skip -((" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")) > 0) * " "(" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")), 0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 3*32+18)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" " .long 661b - .\n" " .long " "664""2""f - .\n" " .word " "( 1*32+27)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""2""f-""664""2""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "lfence; rdtsc" "\n" "665""1" ":\n" "# ALT: replacement " "2" "\n" "664""2"":\n\t" "rdtscp" "\n" "665""2" ":\n" ".popsection\n"
>
>
>   : "=a" (low), "=d" (high)
>
>   :: "ecx");
>
> return ((low) | (high) << 32);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long long native_read_pmc(int counter)
>{
> unsigned long low, high;
>
> asm volatile("rdpmc" : "=a" (low), "=d" (high) : "c" (counter));
> if (static_key_false(&(__tracepoint_rdpmc).key))
>  do_trace_rdpmc(counter, ((low) | (high) << 32), 0);
> return ((low) | (high) << 32);
>}
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/frame.h" 1
># 100 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/frame.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long encode_frame_pointer(struct pt_regs *regs)
>{
> return 0;
>}
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h" 2
>
>u64 dummy_steal_clock(int cpu);
>u64 dummy_sched_clock(void);
>
>extern struct static_call_key __SCK__pv_steal_clock; extern struct static_call_tramp __SCT__pv_steal_clock; extern typeof(dummy_steal_clock) __SCtype__pv_steal_clock;
>extern struct static_call_key __SCK__pv_sched_clock; extern struct static_call_tramp __SCT__pv_sched_clock; extern typeof(dummy_sched_clock) __SCtype__pv_sched_clock;
>
>void paravirt_set_sched_clock(u64 (*func)(void));
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 paravirt_sched_clock(void)
>{
> return ({ static void * __attribute__((__section__(".discard.addressable"))) __attribute__((__used__)) __UNIQUE_ID___addressable___SCK__pv_sched_clock35 = (void *)&__SCK__pv_sched_clock;; ((typeof(&__SCtype__pv_sched_clock))&__SCT__pv_sched_clock); })();
>}
>
>struct static_key;
>extern struct static_key paravirt_steal_enabled;
>extern struct static_key paravirt_steal_rq_enabled;
>
>__attribute__((__externally_visible__)) void __native_queued_spin_unlock(struct qspinlock *lock);
>bool pv_is_native_spin_unlock(void);
>__attribute__((__externally_visible__)) bool __native_vcpu_is_preempted(long cpu);
>bool pv_is_native_vcpu_is_preempted(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 paravirt_steal_clock(int cpu)
>{
> return ({ static void * __attribute__((__section__(".discard.addressable"))) __attribute__((__used__)) __UNIQUE_ID___addressable___SCK__pv_steal_clock36 = (void *)&__SCK__pv_steal_clock;; ((typeof(&__SCtype__pv_steal_clock))&__SCT__pv_steal_clock); })(cpu);
>}
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) paravirt_set_cap(void);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void slow_down_io(void)
>{
> pv_ops.cpu.io_delay();
>
>
>
>
>
>}
>
>void native_flush_tlb_local(void);
>void native_flush_tlb_global(void);
>void native_flush_tlb_one_user(unsigned long addr);
>void native_flush_tlb_multi(const struct cpumask *cpumask,
>        const struct flush_tlb_info *info);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __flush_tlb_local(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.flush_tlb_user); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.flush_tlb_user) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.flush_tlb_user)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __flush_tlb_global(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.flush_tlb_kernel); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.flush_tlb_kernel) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.flush_tlb_kernel)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __flush_tlb_one_user(unsigned long addr)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.flush_tlb_one_user); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.flush_tlb_one_user) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.flush_tlb_one_user)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(addr)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __flush_tlb_multi(const struct cpumask *cpumask,
>          const struct flush_tlb_info *info)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.flush_tlb_multi); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.flush_tlb_multi) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.flush_tlb_multi)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(cpumask)), "S" ((unsigned long)(info)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_tlb_remove_table(struct mmu_gather *tlb, void *table)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.tlb_remove_table); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.tlb_remove_table) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.tlb_remove_table)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(tlb)), "S" ((unsigned long)(table)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_arch_exit_mmap(struct mm_struct *mm)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.exit_mmap); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.exit_mmap) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.exit_mmap)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void notify_page_enc_status_changed(unsigned long pfn,
>        int npages, bool enc)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.notify_page_enc_status_changed); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.notify_page_enc_status_changed) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.notify_page_enc_status_changed)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pfn)), "S" ((unsigned long)(npages)), "d" ((unsigned long)(enc)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_sp0(unsigned long sp0)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.load_sp0); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.load_sp0) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.load_sp0)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(sp0)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __cpuid(unsigned int *eax, unsigned int *ebx,
>      unsigned int *ecx, unsigned int *edx)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.cpuid); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.cpuid) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.cpuid)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(eax)), "S" ((unsigned long)(ebx)), "d" ((unsigned long)(ecx)), "c" ((unsigned long)(edx)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long paravirt_get_debugreg(int reg)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.get_debugreg); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.get_debugreg) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.get_debugreg)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(reg)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_37(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(unsigned long) > sizeof(unsigned long)"))); if (!(!(sizeof(unsigned long) > sizeof(unsigned long)))) __compiletime_assert_37(); } while (0); switch (sizeof(unsigned long)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_debugreg(unsigned long val, int reg)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.set_debugreg); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.set_debugreg) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.set_debugreg)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(reg)), "S" ((unsigned long)(val)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long read_cr0(void)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.read_cr0); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.read_cr0) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.read_cr0)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_38(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(unsigned long) > sizeof(unsigned long)"))); if (!(!(sizeof(unsigned long) > sizeof(unsigned long)))) __compiletime_assert_38(); } while (0); switch (sizeof(unsigned long)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_cr0(unsigned long x)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_cr0); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_cr0) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_cr0)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(x)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long read_cr2(void)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.read_cr2.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%cr2, %%rax;" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.read_cr2.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.read_cr2.func)), [paravirt_clobber] "i" (((1 << 0))) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_39(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(unsigned long) > sizeof(unsigned long)"))); if (!(!(sizeof(unsigned long) > sizeof(unsigned long)))) __compiletime_assert_39(); } while (0); switch (sizeof(unsigned long)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>
>                               ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_cr2(unsigned long x)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.write_cr2); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.write_cr2) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.write_cr2)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(x)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __read_cr3(void)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.read_cr3); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%cr3, %%rax;" "\n" "665""1" ":\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.read_cr3) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.read_cr3)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_40(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(unsigned long) > sizeof(unsigned long)"))); if (!(!(sizeof(unsigned long) > sizeof(unsigned long)))) __compiletime_assert_40(); } while (0); switch (sizeof(unsigned long)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                         ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_cr3(unsigned long x)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.write_cr3); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%cr3" "\n" "665""1" ":\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.write_cr3) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.write_cr3)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(x)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; })
>                                                  ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __write_cr4(unsigned long x)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_cr4); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_cr4) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_cr4)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(x)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_safe_halt(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.irq.safe_halt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, irq.safe_halt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.irq.safe_halt)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void halt(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.irq.halt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, irq.halt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.irq.halt)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wbinvd(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.wbinvd); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "wbinvd" "\n" "665""1" ":\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.wbinvd) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.wbinvd)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 paravirt_read_msr(unsigned msr)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.read_msr); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.read_msr) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.read_msr)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(msr)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_41(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(u64) > sizeof(unsigned long)"))); if (!(!(sizeof(u64) > sizeof(unsigned long)))) __compiletime_assert_41(); } while (0); switch (sizeof(u64)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_write_msr(unsigned msr,
>          unsigned low, unsigned high)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_msr); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_msr) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_msr)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(msr)), "S" ((unsigned long)(low)), "d" ((unsigned long)(high)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 paravirt_read_msr_safe(unsigned msr, int *err)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.read_msr_safe); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.read_msr_safe) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.read_msr_safe)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(msr)), "S" ((unsigned long)(err)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_42(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(u64) > sizeof(unsigned long)"))); if (!(!(sizeof(u64) > sizeof(unsigned long)))) __compiletime_assert_42(); } while (0); switch (sizeof(u64)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int paravirt_write_msr_safe(unsigned msr,
>       unsigned low, unsigned high)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_msr_safe); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_msr_safe) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_msr_safe)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(msr)), "S" ((unsigned long)(low)), "d" ((unsigned long)(high)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_43(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(int) > sizeof(unsigned long)"))); if (!(!(sizeof(int) > sizeof(unsigned long)))) __compiletime_assert_43(); } while (0); switch (sizeof(int)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
># 225 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wrmsrl(unsigned msr, u64 val)
>{
> do { paravirt_write_msr(msr, (u32)val, (u32)(val>>32)); } while (0);
>}
># 242 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rdmsrl_safe(unsigned msr, unsigned long long *p)
>{
> int err;
>
> *p = paravirt_read_msr_safe(msr, &err);
> return err;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long long paravirt_read_pmc(int counter)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.read_pmc); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.read_pmc) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.read_pmc)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(counter)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_44(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(u64) > sizeof(unsigned long)"))); if (!(!(sizeof(u64) > sizeof(unsigned long)))) __compiletime_assert_44(); } while (0); switch (sizeof(u64)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
># 264 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_alloc_ldt(struct desc_struct *ldt, unsigned entries)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.alloc_ldt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.alloc_ldt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.alloc_ldt)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(ldt)), "S" ((unsigned long)(entries)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_free_ldt(struct desc_struct *ldt, unsigned entries)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.free_ldt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.free_ldt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.free_ldt)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(ldt)), "S" ((unsigned long)(entries)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_TR_desc(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.load_tr_desc); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.load_tr_desc) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.load_tr_desc)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_gdt(const struct desc_ptr *dtr)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.load_gdt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.load_gdt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.load_gdt)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(dtr)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_idt(const struct desc_ptr *dtr)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.load_idt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.load_idt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.load_idt)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(dtr)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_ldt(const void *addr, unsigned entries)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.set_ldt); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.set_ldt) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.set_ldt)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(addr)), "S" ((unsigned long)(entries)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long paravirt_store_tr(void)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.store_tr); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.store_tr) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.store_tr)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_45(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(unsigned long) > sizeof(unsigned long)"))); if (!(!(sizeof(unsigned long) > sizeof(unsigned long)))) __compiletime_assert_45(); } while (0); switch (sizeof(unsigned long)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_TLS(struct thread_struct *t, unsigned cpu)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.load_tls); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.load_tls) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.load_tls)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(t)), "S" ((unsigned long)(cpu)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_gs_index(unsigned int gs)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.load_gs_index); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.load_gs_index) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.load_gs_index)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(gs)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_ldt_entry(struct desc_struct *dt, int entry,
>       const void *desc)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_ldt_entry); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_ldt_entry) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_ldt_entry)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(dt)), "S" ((unsigned long)(entry)), "d" ((unsigned long)(desc)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_gdt_entry(struct desc_struct *dt, int entry,
>       void *desc, int type)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_gdt_entry); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_gdt_entry) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_gdt_entry)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(dt)), "S" ((unsigned long)(entry)), "d" ((unsigned long)(desc)), "c" ((unsigned long)(type)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_idt_entry(gate_desc *dt, int entry, const gate_desc *g)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.write_idt_entry); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.write_idt_entry) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.write_idt_entry)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(dt)), "S" ((unsigned long)(entry)), "d" ((unsigned long)(g)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tss_invalidate_io_bitmap(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.invalidate_io_bitmap); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.invalidate_io_bitmap) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.invalidate_io_bitmap)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tss_update_io_bitmap(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.update_io_bitmap); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.update_io_bitmap) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.update_io_bitmap)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_activate_mm(struct mm_struct *prev,
>     struct mm_struct *next)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.activate_mm); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.activate_mm) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.activate_mm)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(prev)), "S" ((unsigned long)(next)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_arch_dup_mmap(struct mm_struct *oldmm,
>       struct mm_struct *mm)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.dup_mmap); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.dup_mmap) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.dup_mmap)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(oldmm)), "S" ((unsigned long)(mm)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int paravirt_pgd_alloc(struct mm_struct *mm)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.pgd_alloc); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.pgd_alloc) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.pgd_alloc)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_46(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(int) > sizeof(unsigned long)"))); if (!(!(sizeof(int) > sizeof(unsigned long)))) __compiletime_assert_46(); } while (0); switch (sizeof(int)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_pgd_free(struct mm_struct *mm, pgd_t *pgd)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.pgd_free); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.pgd_free) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.pgd_free)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)), "S" ((unsigned long)(pgd)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_alloc_pte(struct mm_struct *mm, unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.alloc_pte); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.alloc_pte) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.alloc_pte)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)), "S" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_release_pte(unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.release_pte); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.release_pte) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.release_pte)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_alloc_pmd(struct mm_struct *mm, unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.alloc_pmd); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.alloc_pmd) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.alloc_pmd)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)), "S" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_release_pmd(unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.release_pmd); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.release_pmd) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.release_pmd)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_alloc_pud(struct mm_struct *mm, unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.alloc_pud); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.alloc_pud) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.alloc_pud)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)), "S" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_release_pud(unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.release_pud); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.release_pud) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.release_pud)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_alloc_p4d(struct mm_struct *mm, unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.alloc_p4d); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.alloc_p4d) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.alloc_p4d)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(mm)), "S" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void paravirt_release_p4d(unsigned long pfn)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.release_p4d); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.release_p4d) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.release_p4d)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pfn)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t __pte(pteval_t val)
>{
> return (pte_t) { ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.make_pte.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.make_pte.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.make_pte.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(val)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_47(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pteval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pteval_t) > sizeof(unsigned long)))) __compiletime_assert_47(); } while (0); switch (sizeof(pteval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>
>                                   };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pteval_t pte_val(pte_t pte)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.pte_val.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.pte_val.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.pte_val.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(pte.pte)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_48(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pteval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pteval_t) > sizeof(unsigned long)))) __compiletime_assert_48(); } while (0); switch (sizeof(pteval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                   ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgd_t __pgd(pgdval_t val)
>{
> return (pgd_t) { ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.make_pgd.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.make_pgd.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.make_pgd.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(val)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_49(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pgdval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pgdval_t) > sizeof(unsigned long)))) __compiletime_assert_49(); } while (0); switch (sizeof(pgdval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>
>                                   };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgdval_t pgd_val(pgd_t pgd)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.pgd_val.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.pgd_val.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.pgd_val.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(pgd.pgd)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_50(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pgdval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pgdval_t) > sizeof(unsigned long)))) __compiletime_assert_50(); } while (0); switch (sizeof(pgdval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                   ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t ptep_modify_prot_start(struct vm_area_struct *vma, unsigned long addr,
>        pte_t *ptep)
>{
> pteval_t ret;
>
> ret = ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.ptep_modify_prot_start); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.ptep_modify_prot_start) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.ptep_modify_prot_start)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(vma)), "S" ((unsigned long)(addr)), "d" ((unsigned long)(ptep)) : "memory", "cc" , "r8", "r9", "r10", "r11"); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_51(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pteval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pteval_t) > sizeof(unsigned long)))) __compiletime_assert_51(); } while (0); switch (sizeof(pteval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); });
>
> return (pte_t) { .pte = ret };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptep_modify_prot_commit(struct vm_area_struct *vma, unsigned long addr,
>        pte_t *ptep, pte_t old_pte, pte_t pte)
>{
>
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.ptep_modify_prot_commit); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.ptep_modify_prot_commit) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.ptep_modify_prot_commit)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(vma)), "S" ((unsigned long)(addr)), "d" ((unsigned long)(ptep)), "c" ((unsigned long)(pte.pte)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pte(pte_t *ptep, pte_t pte)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.set_pte); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.set_pte) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.set_pte)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(ptep)), "S" ((unsigned long)(pte.pte)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pmd(pmd_t *pmdp, pmd_t pmd)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.set_pmd); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.set_pmd) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.set_pmd)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pmdp)), "S" ((unsigned long)(native_pmd_val(pmd))) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t __pmd(pmdval_t val)
>{
> return (pmd_t) { ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.make_pmd.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.make_pmd.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.make_pmd.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(val)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_52(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pmdval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pmdval_t) > sizeof(unsigned long)))) __compiletime_assert_52(); } while (0); switch (sizeof(pmdval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>
>                                   };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmdval_t pmd_val(pmd_t pmd)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.pmd_val.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.pmd_val.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.pmd_val.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(pmd.pmd)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_53(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pmdval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pmdval_t) > sizeof(unsigned long)))) __compiletime_assert_53(); } while (0); switch (sizeof(pmdval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                   ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pud(pud_t *pudp, pud_t pud)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.set_pud); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.set_pud) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.set_pud)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pudp)), "S" ((unsigned long)(native_pud_val(pud))) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t __pud(pudval_t val)
>{
> pudval_t ret;
>
> ret = ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.make_pud.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.make_pud.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.make_pud.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(val)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_54(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pudval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pudval_t) > sizeof(unsigned long)))) __compiletime_assert_54(); } while (0); switch (sizeof(pudval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                         ;
>
> return (pud_t) { ret };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pudval_t pud_val(pud_t pud)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.pud_val.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.pud_val.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.pud_val.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(pud.pud)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_55(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(pudval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(pudval_t) > sizeof(unsigned long)))) __compiletime_assert_55(); } while (0); switch (sizeof(pudval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                   ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pud_clear(pud_t *pudp)
>{
> set_pud(pudp, native_make_pud(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_p4d(p4d_t *p4dp, p4d_t p4d)
>{
> p4dval_t val = native_p4d_val(p4d);
>
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.set_p4d); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.set_p4d) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.set_p4d)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(p4dp)), "S" ((unsigned long)(val)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4d_t __p4d(p4dval_t val)
>{
> p4dval_t ret = ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.make_p4d.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.make_p4d.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.make_p4d.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(val)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_56(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(p4dval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(p4dval_t) > sizeof(unsigned long)))) __compiletime_assert_56(); } while (0); switch (sizeof(p4dval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>
>                                ;
>
> return (p4d_t) { ret };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4dval_t p4d_val(p4d_t p4d)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.p4d_val.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "mov %%rdi, %%rax" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.p4d_val.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.p4d_val.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(p4d.p4d)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_57(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(p4dval_t) > sizeof(unsigned long)"))); if (!(!(sizeof(p4dval_t) > sizeof(unsigned long)))) __compiletime_assert_57(); } while (0); switch (sizeof(p4dval_t)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                                                   ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __set_pgd(pgd_t *pgdp, pgd_t pgd)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.set_pgd); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.set_pgd) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.set_pgd)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(pgdp)), "S" ((unsigned long)(native_pgd_val(pgd))) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
># 531 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void p4d_clear(p4d_t *p4dp)
>{
> set_p4d(p4dp, native_make_p4d(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pte_atomic(pte_t *ptep, pte_t pte)
>{
> set_pte(ptep, pte);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pte_clear(struct mm_struct *mm, unsigned long addr,
>        pte_t *ptep)
>{
> set_pte(ptep, native_make_pte(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pmd_clear(pmd_t *pmdp)
>{
> set_pmd(pmdp, native_make_pmd(0));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_start_context_switch(struct task_struct *prev)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.start_context_switch); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.start_context_switch) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.start_context_switch)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(prev)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_end_context_switch(struct task_struct *next)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.cpu.end_context_switch); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, cpu.end_context_switch) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.cpu.end_context_switch)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(next)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_enter_lazy_mmu_mode(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.lazy_mode.enter); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.lazy_mode.enter) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.lazy_mode.enter)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_leave_lazy_mmu_mode(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.lazy_mode.leave); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.lazy_mode.leave) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.lazy_mode.leave)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_flush_lazy_mmu_mode(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.mmu.lazy_mode.flush); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, mmu.lazy_mode.flush) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.mmu.lazy_mode.flush)), [paravirt_clobber] "i" (((1 << 9) - 1)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __set_fixmap(unsigned idx,
>    phys_addr_t phys, pgprot_t flags)
>{
> pv_ops.mmu.set_fixmap(idx, phys, flags);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void pv_queued_spin_lock_slowpath(struct qspinlock *lock,
>       u32 val)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.lock.queued_spin_lock_slowpath); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, lock.queued_spin_lock_slowpath) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.lock.queued_spin_lock_slowpath)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(lock)), "S" ((unsigned long)(val)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void pv_queued_spin_unlock(struct qspinlock *lock)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.lock.queued_spin_unlock.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+20)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "movb $0, (%%" "rdi" ");" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, lock.queued_spin_unlock.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.lock.queued_spin_unlock.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(lock)) : "memory", "cc" ); ; })
>
>                                   ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void pv_wait(u8 *ptr, u8 val)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.lock.wait); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, lock.wait) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.lock.wait)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(ptr)), "S" ((unsigned long)(val)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void pv_kick(int cpu)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.lock.kick); asm volatile("771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" : "=D" (__edi), "=S" (__esi), "=d" (__edx), "=c" (__ecx), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, lock.kick) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.lock.kick)), [paravirt_clobber] "i" (((1 << 9) - 1)), "D" ((unsigned long)(cpu)) : "memory", "cc" , "rax", "r8", "r9", "r10", "r11"); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool pv_vcpu_is_preempted(long cpu)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.lock.vcpu_is_preempted.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+21)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "xor %%" "rax" ", %%" "rax" ";" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, lock.vcpu_is_preempted.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.lock.vcpu_is_preempted.func)), [paravirt_clobber] "i" (((1 << 0))), "D" ((unsigned long)(cpu)) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_58(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(bool) > sizeof(unsigned long)"))); if (!(!(sizeof(bool) > sizeof(unsigned long)))) __compiletime_assert_58(); } while (0); switch (sizeof(bool)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>
>                                     ;
>}
>
>void __raw_callee_save___native_queued_spin_unlock(struct qspinlock *lock);
>bool __raw_callee_save___native_vcpu_is_preempted(long cpu);
># 690 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) unsigned long arch_local_save_flags(void)
>{
> return ({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.irq.save_fl.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "pushf; pop %%rax;" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, irq.save_fl.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.irq.save_fl.func)), [paravirt_clobber] "i" (((1 << 0))) : "memory", "cc" ); ({ unsigned long __mask = ~0UL; do { extern void __compiletime_assert_59(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(unsigned long) > sizeof(unsigned long)"))); if (!(!(sizeof(unsigned long) > sizeof(unsigned long)))) __compiletime_assert_59(); } while (0); switch (sizeof(unsigned long)) { case 1: __mask = 0xffUL; break; case 2: __mask = 0xffffUL; break; case 4: __mask = 0xffffffffUL; break; default: break; } __mask & __eax; }); })
>                               ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void arch_local_irq_disable(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.irq.irq_disable.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "cli;" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, irq.irq_disable.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.irq.irq_disable.func)), [paravirt_clobber] "i" (((1 << 0))) : "memory", "cc" ); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void arch_local_irq_enable(void)
>{
> (void)({ unsigned long __edi = __edi, __esi = __esi, __edx = __edx, __ecx = __ecx, __eax = __eax;; ((void)pv_ops.irq.irq_enable.func); asm volatile("# ALT: oldnstr\n" "661:\n\t" "771:\n\t" "999:\n\t" ".pushsection .discard.retpoline_safe\n\t" " " ".quad" " " " 999b\n\t" ".popsection\n\t" "call *%c[paravirt_opptr];" "\n" "772:\n" ".pushsection .parainstructions,\"a\"\n" " " ".balign 8" " " "\n" " " ".quad" " " " 771b\n" "  .byte " "%c[paravirt_typenum]" "\n" "  .byte 772b-771b\n" "  .short " "%c[paravirt_clobber]" "\n" ".popsection\n" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "((( 8*32+16)) | (1 << 15))" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "sti;" "\n" "665""1" ":\n" ".popsection\n" : "=a" (__eax), "+r" (current_stack_pointer) : [paravirt_typenum] "i" ((__builtin_offsetof(struct paravirt_patch_template, irq.irq_enable.func) / sizeof(void *))), [paravirt_opptr] "i" (&(pv_ops.irq.irq_enable.func)), [paravirt_clobber] "i" (((1 << 0))) : "memory", "cc" ); ; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) unsigned long arch_local_irq_save(void)
>{
> unsigned long f;
>
> f = arch_local_save_flags();
> arch_local_irq_disable();
> return f;
>}
># 732 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/paravirt.h"
>extern void default_banner(void);
># 247 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h" 2
># 313 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/msr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int wrmsrl_safe(u32 msr, u64 val)
>{
> return paravirt_write_msr_safe(msr, (u32)val, (u32)(val >> 32));
>}
>
>struct msr *msrs_alloc(void);
>void msrs_free(struct msr *msrs);
>int msr_set_bit(u32 msr, u8 bit);
>int msr_clear_bit(u32 msr, u8 bit);
>
>
>int rdmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
>int wrmsr_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
>int rdmsrl_on_cpu(unsigned int cpu, u32 msr_no, u64 *q);
>int wrmsrl_on_cpu(unsigned int cpu, u32 msr_no, u64 q);
>void rdmsr_on_cpus(const struct cpumask *mask, u32 msr_no, struct msr *msrs);
>void wrmsr_on_cpus(const struct cpumask *mask, u32 msr_no, struct msr *msrs);
>int rdmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 *l, u32 *h);
>int wrmsr_safe_on_cpu(unsigned int cpu, u32 msr_no, u32 l, u32 h);
>int rdmsrl_safe_on_cpu(unsigned int cpu, u32 msr_no, u64 *q);
>int wrmsrl_safe_on_cpu(unsigned int cpu, u32 msr_no, u64 q);
>int rdmsr_safe_regs_on_cpu(unsigned int cpu, u32 regs[8]);
>int wrmsr_safe_regs_on_cpu(unsigned int cpu, u32 regs[8]);
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/irqflags.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/irqflags.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irqflags.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irqflags.h"
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long native_save_fl(void);
>extern inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long native_save_fl(void)
>{
> unsigned long flags;
>
>
>
>
>
>
> asm volatile("# __raw_save_flags\n\t"
>       "pushf ; pop %0"
>       : "=rm" (flags)
>       :
>       : "memory");
>
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void native_irq_disable(void)
>{
> asm volatile("cli": : :"memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void native_irq_enable(void)
>{
> asm volatile("sti": : :"memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__section__(".cpuidle.text"))) void native_safe_halt(void)
>{
> mds_idle_clear_cpu_buffers();
> asm volatile("sti; hlt": : :"memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__section__(".cpuidle.text"))) void native_halt(void)
>{
> mds_idle_clear_cpu_buffers();
> asm volatile("hlt": : :"memory");
>}
># 125 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irqflags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_irqs_disabled_flags(unsigned long flags)
>{
> return !(flags & (((1UL)) << (9)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int arch_irqs_disabled(void)
>{
> unsigned long flags = arch_local_save_flags();
>
> return arch_irqs_disabled_flags(flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void arch_local_irq_restore(unsigned long flags)
>{
> if (!arch_irqs_disabled_flags(flags))
>  arch_local_irq_enable();
>}
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/irqflags.h" 2
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/irqflags.h"
>  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_softirqs_on(unsigned long ip) { }
>  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_softirqs_off(unsigned long ip) { }
>  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_hardirqs_on_prepare(unsigned long ip) { }
>  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_hardirqs_on(unsigned long ip) { }
>  static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_hardirqs_off(unsigned long ip) { }
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
>void native_write_cr0(unsigned long val);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long native_read_cr0(void)
>{
> unsigned long val;
> asm volatile("mov %%cr0,%0\n\t" : "=r" (val) : "m"(*(unsigned int *)0x1000UL));
> return val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long native_read_cr2(void)
>{
> unsigned long val;
> asm volatile("mov %%cr2,%0\n\t" : "=r" (val) : "m"(*(unsigned int *)0x1000UL));
> return val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void native_write_cr2(unsigned long val)
>{
> asm volatile("mov %0,%%cr2": : "r" (val) : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __native_read_cr3(void)
>{
> unsigned long val;
> asm volatile("mov %%cr3,%0\n\t" : "=r" (val) : "m"(*(unsigned int *)0x1000UL));
> return val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_write_cr3(unsigned long val)
>{
> asm volatile("mov %0,%%cr3": : "r" (val) : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long native_read_cr4(void)
>{
> unsigned long val;
># 72 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
> asm volatile("mov %%cr4,%0\n\t" : "=r" (val) : "m"(*(unsigned int *)0x1000UL));
>
> return val;
>}
>
>void native_write_cr4(unsigned long val);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 rdpkru(void)
>{
> u32 ecx = 0;
> u32 edx, pkru;
>
>
>
>
>
> asm volatile(".byte 0x0f,0x01,0xee\n\t"
>       : "=a" (pkru), "=d" (edx)
>       : "c" (ecx));
> return pkru;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wrpkru(u32 pkru)
>{
> u32 ecx = 0, edx = 0;
>
>
>
>
>
> asm volatile(".byte 0x0f,0x01,0xef\n\t"
>       : : "a" (pkru), "c"(ecx), "d"(edx));
>}
># 118 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_wbinvd(void)
>{
> asm volatile("wbinvd": : :"memory");
>}
>
>extern void asm_load_gs_index(unsigned int selector);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_load_gs_index(unsigned int selector)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> asm_load_gs_index(selector);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __read_cr4(void)
>{
> return native_read_cr4();
>}
># 198 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clflush(volatile void *__p)
>{
> asm volatile("clflush %0" : "+m" (*(volatile char *)__p));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clflushopt(volatile void *__p)
>{
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" ".byte 0x3e; clflush %P0" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 9*32+23)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" ".byte 0x66; clflush %P0" "\n" "665""1" ":\n" ".popsection\n" : "+m" (*(volatile char *)__p) : "i" (0))
>
>
>                                              ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clwb(volatile void *__p)
>{
> volatile struct { char x[64]; } *p = __p;
>
> asm volatile("# ALT: oldinstr2\n" "661:\n\t" ".byte 0x3e; clflush (%[pax])" "\n662:\n" "# ALT: padding2\n" ".skip -((" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")) > 0) * " "(" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")), 0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 9*32+23)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" " .long 661b - .\n" " .long " "664""2""f - .\n" " .word " "( 9*32+24)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""2""f-""664""2""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" ".byte 0x66; clflush (%[pax])" "\n" "665""1" ":\n" "# ALT: replacement " "2" "\n" "664""2"":\n\t" ".byte 0x66, 0x0f, 0xae, 0x30" "\n" "665""2" ":\n" ".popsection\n"
>
>
>
>
>
>  : [p] "+m" (*p)
>  : [pax] "a" (p));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void serialize(void)
>{
>
> asm volatile(".byte 0xf, 0x1, 0xe8" ::: "memory");
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void movdir64b(void *dst, const void *src)
>{
> const struct { char _[64]; } *__src = src;
> struct { char _[64]; } *__dst = dst;
># 250 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
> asm volatile(".byte 0x66, 0x0f, 0x38, 0xf8, 0x02"
>       : "+m" (*__dst)
>       : "m" (*__src), "a" (__dst), "d" (__src));
>}
># 274 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/special_insns.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int enqcmds(void *dst, const void *src)
>{
> const struct { char _[64]; } *__src = src;
> struct { char _[64]; } *__dst = dst;
> bool zf;
>
>
>
>
>
>
> asm volatile(".byte 0xf3, 0x0f, 0x38, 0xf8, 0x02, 0x66, 0x90"
>       "\n\t/* output condition code " "z" "*/\n"
>       : "=@cc" "z" (zf), "+m" (*__dst)
>       : "m" (*__src), "a" (__dst), "d" (__src));
>
>
> if (zf)
>  return -11;
>
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tile_release(void)
>{
>
>
>
>
> asm volatile(".byte 0xc4, 0xe2, 0x78, 0x49, 0xc0");
>}
># 26 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
>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];
> };
>
>} __attribute__((aligned(16)));
># 79 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
>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;
>};
>
>
>
>
>enum xfeature {
> XFEATURE_FP,
> XFEATURE_SSE,
>
>
>
>
> XFEATURE_YMM,
> XFEATURE_BNDREGS,
> XFEATURE_BNDCSR,
> XFEATURE_OPMASK,
> XFEATURE_ZMM_Hi256,
> XFEATURE_Hi16_ZMM,
> XFEATURE_PT_UNIMPLEMENTED_SO_FAR,
> XFEATURE_PKRU,
> XFEATURE_PASID,
> XFEATURE_RSRVD_COMP_11,
> XFEATURE_RSRVD_COMP_12,
> XFEATURE_RSRVD_COMP_13,
> XFEATURE_RSRVD_COMP_14,
> XFEATURE_LBR,
> XFEATURE_RSRVD_COMP_16,
> XFEATURE_XTILE_CFG,
> XFEATURE_XTILE_DATA,
>
> XFEATURE_MAX,
>};
># 159 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
>struct reg_128_bit {
> u8 regbytes[128/8];
>};
>struct reg_256_bit {
> u8 regbytes[256/8];
>};
>struct reg_512_bit {
> u8 regbytes[512/8];
>};
>struct reg_1024_byte {
> u8 regbytes[1024];
>};
># 182 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
>struct ymmh_struct {
> struct reg_128_bit hi_ymm[16];
>} __attribute__((__packed__));
>
>
>
>struct mpx_bndreg {
> u64 lower_bound;
> u64 upper_bound;
>} __attribute__((__packed__));
>
>
>
>struct mpx_bndreg_state {
> struct mpx_bndreg bndreg[4];
>} __attribute__((__packed__));
>
>
>
>
>
>
>struct mpx_bndcsr {
> u64 bndcfgu;
> u64 bndstatus;
>} __attribute__((__packed__));
>
>
>
>
>struct mpx_bndcsr_state {
> union {
>  struct mpx_bndcsr bndcsr;
>  u8 pad_to_64_bytes[64];
> };
>} __attribute__((__packed__));
>
>
>
>
>
>
>
>struct avx_512_opmask_state {
> u64 opmask_reg[8];
>} __attribute__((__packed__));
>
>
>
>
>
>
>struct avx_512_zmm_uppers_state {
> struct reg_256_bit zmm_upper[16];
>} __attribute__((__packed__));
>
>
>
>
>
>struct avx_512_hi16_state {
> struct reg_512_bit hi16_zmm[16];
>} __attribute__((__packed__));
>
>
>
>
>
>struct pkru_state {
> u32 pkru;
> u32 pad;
>} __attribute__((__packed__));
>
>
>
>
>
>
>struct lbr_entry {
> u64 from;
> u64 to;
> u64 info;
>};
>
>struct arch_lbr_state {
> u64 lbr_ctl;
> u64 lbr_depth;
> u64 ler_from;
> u64 ler_to;
> u64 ler_info;
> struct lbr_entry entries[];
>};
>
>
>
>
>struct xtile_cfg {
> u64 tcfg[8];
>} __attribute__((__packed__));
>
>
>
>
>
>
>
>struct xtile_data {
> struct reg_1024_byte tmm;
>} __attribute__((__packed__));
>
>
>
>
>
>struct ia32_pasid_state {
> u64 pasid;
>} __attribute__((__packed__));
>
>struct xstate_header {
> u64 xfeatures;
> u64 xcomp_bv;
> u64 reserved[6];
>} __attribute__((packed));
># 321 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
>struct xregs_state {
> struct fxregs_state i387;
> struct xstate_header header;
> u8 extended_state_area[0];
>} __attribute__ ((packed, aligned (64)));
># 336 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
>union fpregs_state {
> struct fregs_state fsave;
> struct fxregs_state fxsave;
> struct swregs_state soft;
> struct xregs_state xsave;
> u8 __padding[((1UL) << 12)];
>};
>
>struct fpstate {
>
> unsigned int size;
>
>
> unsigned int user_size;
>
>
> u64 xfeatures;
>
>
> u64 user_xfeatures;
>
>
> u64 xfd;
>
>
> unsigned int is_valloc : 1;
>
>
> unsigned int is_guest : 1;
># 379 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
> unsigned int is_confidential : 1;
>
>
> unsigned int in_use : 1;
>
>
> union fpregs_state regs;
>
>
>} __attribute__((__aligned__(64)));
>
>struct fpu_state_perm {
># 410 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
> u64 __state_perm;
>
>
>
>
>
>
>
> unsigned int __state_size;
>
>
>
>
>
>
>
> unsigned int __user_state_size;
>};
>
>
>
>
>
>
>struct fpu {
># 447 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
> unsigned int last_cpu;
>
>
>
>
>
>
> unsigned long avx512_timestamp;
>
>
>
>
>
>
>
> struct fpstate *fpstate;
>
>
>
>
>
>
>
> struct fpstate *__task_fpstate;
>
>
>
>
>
>
> struct fpu_state_perm perm;
># 487 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
> struct fpstate __fpstate;
>
>
>
>
>};
>
>
>
>
>struct fpu_guest {
>
>
>
> struct fpstate *fpstate;
>};
>
>
>
>
>struct fpu_state_config {
>
>
>
>
>
>
> unsigned int max_size;
># 523 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
> unsigned int default_size;
>
>
>
>
>
>
>
> u64 max_features;
># 540 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/types.h"
> u64 default_features;
>
>
>
>
>
>
> u64 legacy_features;
>};
>
>
>extern struct fpu_state_config fpu_kernel_cfg, fpu_user_cfg;
># 27 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vmxfeatures.h" 1
># 29 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vdso/processor.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vdso/processor.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void rep_nop(void)
>{
> asm volatile("rep; nop" ::: "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void cpu_relax(void)
>{
> rep_nop();
>}
># 30 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/personality.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/personality.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/personality.h"
>enum {
> UNAME26 = 0x0020000,
> ADDR_NO_RANDOMIZE = 0x0040000,
> FDPIC_FUNCPTRS = 0x0080000,
>
>
> MMAP_PAGE_ZERO = 0x0100000,
> ADDR_COMPAT_LAYOUT = 0x0200000,
> READ_IMPLIES_EXEC = 0x0400000,
> ADDR_LIMIT_32BIT = 0x0800000,
> SHORT_INODE = 0x1000000,
> WHOLE_SECONDS = 0x2000000,
> STICKY_TIMEOUTS = 0x4000000,
> ADDR_LIMIT_3GB = 0x8000000,
>};
># 42 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/personality.h"
>enum {
> PER_LINUX = 0x0000,
> PER_LINUX_32BIT = 0x0000 | ADDR_LIMIT_32BIT,
> PER_LINUX_FDPIC = 0x0000 | FDPIC_FUNCPTRS,
> PER_SVR4 = 0x0001 | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
> PER_SVR3 = 0x0002 | STICKY_TIMEOUTS | SHORT_INODE,
> PER_SCOSVR3 = 0x0003 | STICKY_TIMEOUTS |
>      WHOLE_SECONDS | SHORT_INODE,
> PER_OSR5 = 0x0003 | STICKY_TIMEOUTS | WHOLE_SECONDS,
> PER_WYSEV386 = 0x0004 | STICKY_TIMEOUTS | SHORT_INODE,
> PER_ISCR4 = 0x0005 | STICKY_TIMEOUTS,
> PER_BSD = 0x0006,
> PER_SUNOS = 0x0006 | STICKY_TIMEOUTS,
> PER_XENIX = 0x0007 | STICKY_TIMEOUTS | SHORT_INODE,
> PER_LINUX32 = 0x0008,
> PER_LINUX32_3GB = 0x0008 | ADDR_LIMIT_3GB,
> PER_IRIX32 = 0x0009 | STICKY_TIMEOUTS,
> PER_IRIXN32 = 0x000a | STICKY_TIMEOUTS,
> PER_IRIX64 = 0x000b | STICKY_TIMEOUTS,
> PER_RISCOS = 0x000c,
> PER_SOLARIS = 0x000d | STICKY_TIMEOUTS,
> PER_UW7 = 0x000e | STICKY_TIMEOUTS | MMAP_PAGE_ZERO,
> PER_OSF4 = 0x000f,
> PER_HPUX = 0x0010,
> PER_MASK = 0x00ff,
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/personality.h" 2
># 32 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h" 2
># 62 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>enum tlb_infos {
> ENTRIES,
> NR_INFO
>};
>
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lli_4k[NR_INFO];
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lli_2m[NR_INFO];
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lli_4m[NR_INFO];
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lld_4k[NR_INFO];
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lld_2m[NR_INFO];
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lld_4m[NR_INFO];
>extern u16 __attribute__((__section__(".data..read_mostly"))) tlb_lld_1g[NR_INFO];
>
>
>
>
>
>
>
>struct cpuinfo_x86 {
> __u8 x86;
> __u8 x86_vendor;
> __u8 x86_model;
> __u8 x86_stepping;
>
>
> int x86_tlbsize;
>
>
> __u32 vmx_capability[3];
>
> __u8 x86_virt_bits;
> __u8 x86_phys_bits;
>
> __u8 x86_coreid_bits;
> __u8 cu_id;
>
> __u32 extended_cpuid_level;
>
> int cpuid_level;
>
>
>
>
>
> union {
>  __u32 x86_capability[22 + 1];
>  unsigned long x86_capability_alignment;
> };
> char x86_vendor_id[16];
> char x86_model_id[64];
>
> unsigned int x86_cache_size;
> int x86_cache_alignment;
>
> int x86_cache_max_rmid;
> int x86_cache_occ_scale;
> int x86_cache_mbm_width_offset;
> int x86_power;
> unsigned long 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_die_id;
> u16 logical_die_id;
>
> u16 cpu_index;
> u32 microcode;
>
> u8 x86_cache_bits;
> unsigned initialized : 1;
>} __attribute__((__designated_init__));
>
>struct cpuid_regs {
> u32 eax, ebx, ecx, edx;
>};
>
>enum cpuid_regs_idx {
> CPUID_EAX = 0,
> CPUID_EBX,
> CPUID_ECX,
> CPUID_EDX,
>};
># 172 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>extern struct cpuinfo_x86 boot_cpu_data;
>extern struct cpuinfo_x86 new_cpu_data;
>
>extern __u32 cpu_caps_cleared[22 + 1];
>extern __u32 cpu_caps_set[22 + 1];
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_info; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(struct cpuinfo_x86) cpu_info;
>
>
>
>
>
>
>extern const struct seq_operations cpuinfo_op;
>
>
>
>extern void cpu_detect(struct cpuinfo_x86 *c);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long long l1tf_pfn_limit(void)
>{
> return ((((1ULL))) << (boot_cpu_data.x86_cache_bits - 1 - 12));
>}
>
>extern void early_cpu_init(void);
>extern void identify_boot_cpu(void);
>extern void identify_secondary_cpu(struct cpuinfo_x86 *);
>extern void print_cpu_info(struct cpuinfo_x86 *);
>void print_cpu_msr(struct cpuinfo_x86 *);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int have_cpuid_p(void)
>{
> return 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_cpuid(unsigned int *eax, unsigned int *ebx,
>    unsigned int *ecx, unsigned int *edx)
>{
>
> asm volatile("cpuid"
>     : "=a" (*eax),
>       "=b" (*ebx),
>       "=c" (*ecx),
>       "=d" (*edx)
>     : "0" (*eax), "2" (*ecx)
>     : "memory");
>}
># 237 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int native_cpuid_eax(unsigned int op) { unsigned int eax = op, ebx, ecx = 0, edx; native_cpuid(&eax, &ebx, &ecx, &edx); return eax; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int native_cpuid_ebx(unsigned int op) { unsigned int eax = op, ebx, ecx = 0, edx; native_cpuid(&eax, &ebx, &ecx, &edx); return ebx; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int native_cpuid_ecx(unsigned int op) { unsigned int eax = op, ebx, ecx = 0, edx; native_cpuid(&eax, &ebx, &ecx, &edx); return ecx; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int native_cpuid_edx(unsigned int op) { unsigned int eax = op, ebx, ecx = 0, edx; native_cpuid(&eax, &ebx, &ecx, &edx); return edx; }
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long read_cr3_pa(void)
>{
> return __read_cr3() & ((0x7FFFFFFFFFFFF000ull) & ~sme_me_mask);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long native_read_cr3_pa(void)
>{
> return __native_read_cr3() & ((0x7FFFFFFFFFFFF000ull) & ~sme_me_mask);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void load_cr3(pgd_t *pgdir)
>{
> write_cr3((__phys_addr_nodebug((unsigned long)(pgdir)) | sme_me_mask));
>}
># 314 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>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;
>
>} __attribute__((packed));
># 367 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>struct entry_stack {
> char stack[((1UL) << 12)];
>};
>
>struct entry_stack_page {
> struct entry_stack stack;
>} __attribute__((__aligned__(((1UL) << 12))));
>
>
>
>
>struct x86_io_bitmap {
>
> u64 prev_sequence;
># 389 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
> unsigned int prev_max;
>
>
>
>
>
>
>
> unsigned long bitmap[((65536 / 8) / sizeof(long)) + 1];
>
>
>
>
>
> unsigned long mapall[((65536 / 8) / sizeof(long)) + 1];
>};
>
>struct tss_struct {
>
>
>
>
>
> struct x86_hw_tss x86_tss;
>
> struct x86_io_bitmap io_bitmap;
>} __attribute__((__aligned__(((1UL) << 12))));
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_tss_rw; extern __attribute__((section(".data..percpu" "..page_aligned"))) __typeof__(struct tss_struct) cpu_tss_rw __attribute__((__aligned__(((1UL) << 12))));
>
>
>struct irq_stack {
> char stack[(((1UL) << 12) << (2 + 0))];
>} __attribute__((__aligned__((((1UL) << 12) << (2 + 0)))));
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_current_top_of_stack; extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) cpu_current_top_of_stack;
>
>
>struct fixed_percpu_data {
># 436 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
> char gs_base[40];
> unsigned long stack_canary;
>};
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_fixed_percpu_data; extern __attribute__((section(".data..percpu" "..first"))) __typeof__(struct fixed_percpu_data) fixed_percpu_data __attribute__((__externally_visible__));
>extern typeof(fixed_percpu_data) init_per_cpu__fixed_percpu_data;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long cpu_kernelmode_gs_base(int cpu)
>{
> return (unsigned long)(*({ do { const void *__vpp_verify = (typeof((&(fixed_percpu_data.gs_base)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(fixed_percpu_data.gs_base)))) *)((&(fixed_percpu_data.gs_base))))); (typeof((typeof(*((&(fixed_percpu_data.gs_base)))) *)((&(fixed_percpu_data.gs_base))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_hardirq_stack_ptr; extern __attribute__((section(".data..percpu" ""))) __typeof__(void *) hardirq_stack_ptr;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_hardirq_stack_inuse; extern __attribute__((section(".data..percpu" ""))) __typeof__(bool) hardirq_stack_inuse;
>extern void ignore_sysret(void);
>
>
>void current_save_fsgs(void);
># 462 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>struct perf_event;
>
>struct thread_struct {
>
> struct desc_struct tls_array[3];
>
>
>
> unsigned long sp;
>
>
>
> unsigned short es;
> unsigned short ds;
> unsigned short fsindex;
> unsigned short gsindex;
>
>
>
> unsigned long fsbase;
> unsigned long gsbase;
># 493 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
> struct perf_event *ptrace_bps[4];
>
> unsigned long virtual_dr6;
>
> unsigned long ptrace_dr7;
>
> unsigned long cr2;
> unsigned long trap_nr;
> unsigned long error_code;
>
>
>
>
>
> struct io_bitmap *io_bitmap;
>
>
>
>
>
>
> unsigned long iopl_emul;
>
> unsigned int iopl_warn:1;
> unsigned int sig_on_uaccess_err:1;
># 526 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
> u32 pkru;
>
>
> struct fpu fpu;
>
>
>
>
>};
>
>extern void fpu_thread_struct_whitelist(unsigned long *offset, unsigned long *size);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_thread_struct_whitelist(unsigned long *offset,
>      unsigned long *size)
>{
> fpu_thread_struct_whitelist(offset, size);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>native_load_sp0(unsigned long sp0)
>{
> do { do { const void *__vpp_verify = (typeof((&(cpu_tss_rw.x86_tss.sp0)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(cpu_tss_rw.x86_tss.sp0)) { case 1: do { u8 pto_val__ = ((u8)(((unsigned long) sp0) & 0xff)); if (0) { typeof((cpu_tss_rw.x86_tss.sp0)) pto_tmp__; pto_tmp__ = (sp0); (void)pto_tmp__; } asm volatile("mov" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((cpu_tss_rw.x86_tss.sp0)) : [val] "qi" (pto_val__)); } while (0);break; case 2: do { u16 pto_val__ = ((u16)(((unsigned long) sp0) & 0xffff)); if (0) { typeof((cpu_tss_rw.x86_tss.sp0)) pto_tmp__; pto_tmp__ = (sp0); (void)pto_tmp__; } asm volatile("mov" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((cpu_tss_rw.x86_tss.sp0)) : [val] "ri" (pto_val__)); } while (0);break; case 4: do { u32 pto_val__ = ((u32)(((unsigned long) sp0) & 0xffffffff)); if (0) { typeof((cpu_tss_rw.x86_tss.sp0)) pto_tmp__; pto_tmp__ = (sp0); (void)pto_tmp__; } asm volatile("mov" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((cpu_tss_rw.x86_tss.sp0)) : [val] "ri" (pto_val__)); } while (0);break; case 8: do { u64 pto_val__ = ((u64)(sp0)); if (0) { typeof((cpu_tss_rw.x86_tss.sp0)) pto_tmp__; pto_tmp__ = (sp0); (void)pto_tmp__; } asm volatile("mov" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((cpu_tss_rw.x86_tss.sp0)) : [val] "re" (pto_val__)); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void native_swapgs(void)
>{
>
> asm volatile("swapgs" ::: "memory");
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long current_top_of_stack(void)
>{
>
>
>
>
>
> return ({ typeof(cpu_current_top_of_stack) pscr_ret__; do { const void *__vpp_verify = (typeof((&(cpu_current_top_of_stack)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(cpu_current_top_of_stack)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm("mov" "b " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "p" (&(cpu_current_top_of_stack))); (typeof(cpu_current_top_of_stack))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm("mov" "w " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "p" (&(cpu_current_top_of_stack))); (typeof(cpu_current_top_of_stack))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm("mov" "l " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "p" (&(cpu_current_top_of_stack))); (typeof(cpu_current_top_of_stack))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm("mov" "q " "%%""gs"":" "%" "P[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "p" (&(cpu_current_top_of_stack))); (typeof(cpu_current_top_of_stack))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool on_thread_stack(void)
>{
> return (unsigned long)(current_top_of_stack() -
>          current_stack_pointer) < (((1UL) << 12) << (2 + 0));
>}
># 586 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>extern void release_thread(struct task_struct *);
>
>unsigned long __get_wchan(struct task_struct *p);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpuid(unsigned int op,
>    unsigned int *eax, unsigned int *ebx,
>    unsigned int *ecx, unsigned int *edx)
>{
> *eax = op;
> *ecx = 0;
> __cpuid(eax, ebx, ecx, edx);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpuid_count(unsigned int op, int count,
>          unsigned int *eax, unsigned int *ebx,
>          unsigned int *ecx, unsigned int *edx)
>{
> *eax = op;
> *ecx = count;
> __cpuid(eax, ebx, ecx, edx);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpuid_eax(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
>
> return eax;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpuid_ebx(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
>
> return ebx;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpuid_ecx(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
>
> return ecx;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int cpuid_edx(unsigned int op)
>{
> unsigned int eax, ebx, ecx, edx;
>
> cpuid(op, &eax, &ebx, &ecx, &edx);
>
> return edx;
>}
>
>extern void select_idle_routine(const struct cpuinfo_x86 *c);
>extern void amd_e400_c1e_apic_setup(void);
>
>extern unsigned long boot_option_idle_override;
>
>enum idle_boot_override {IDLE_NO_OVERRIDE=0, IDLE_HALT, IDLE_NOMWAIT,
>    IDLE_POLL};
>
>extern void enable_sep_cpu(void);
>extern int sysenter_setup(void);
>
>
>
>extern struct desc_ptr early_gdt_descr;
>
>extern void switch_to_new_gdt(int);
>extern void load_direct_gdt(int);
>extern void load_fixmap_gdt(int);
>extern void load_percpu_segment(int);
>extern void cpu_init(void);
>extern void cpu_init_secondary(void);
>extern void cpu_init_exception_handling(void);
>extern void cr4_init(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_debugctlmsr(void)
>{
> unsigned long debugctlmsr = 0;
>
>
>
>
>
> do { debugctlmsr = paravirt_read_msr(0x000001d9); } while (0);
>
> return debugctlmsr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_debugctlmsr(unsigned long debugctlmsr)
>{
>
>
>
>
> wrmsrl(0x000001d9, debugctlmsr);
>}
>
>extern void set_task_blockstep(struct task_struct *task, bool on);
>
>
>extern int bootloader_type;
>extern int bootloader_version;
>
>extern char ignore_fpu_irq;
># 724 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void prefetch(const void *x)
>{
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "prefetcht0 %P1" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 0*32+25)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "prefetchnta %P1" "\n" "665""1" ":\n" ".popsection\n" : : "i" (0), "m" (*(const char *)x))
>
>                            ;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void prefetchw(const void *x)
>{
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "prefetcht0 %P1" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 6*32+ 8)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "prefetchw %P1" "\n" "665""1" ":\n" ".popsection\n" : : "i" (0), "m" (*(const char *)x))
>
>                            ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void spin_lock_prefetch(const void *x)
>{
> prefetchw(x);
>}
># 771 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>extern unsigned long KSTK_ESP(struct task_struct *task);
>
>
>
>extern void start_thread(struct pt_regs *regs, unsigned long new_ip,
>            unsigned long new_sp);
># 791 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/processor.h"
>extern int get_tsc_mode(unsigned long adr);
>extern int set_tsc_mode(unsigned int val);
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_msr_misc_features_shadow; extern __attribute__((section(".data..percpu" ""))) __typeof__(u64) msr_misc_features_shadow;
>
>extern u16 get_llc_id(unsigned int cpu);
>
>
>extern u32 amd_get_nodes_per_socket(void);
>extern u32 amd_get_highest_perf(void);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) uint32_t hypervisor_cpuid_base(const char *sig, uint32_t leaves)
>{
> uint32_t base, eax, signature[3];
>
> for (base = 0x40000000; base < 0x40010000; base += 0x100) {
>  cpuid(base, &eax, &signature[0], &signature[1], &signature[2]);
>
>  if (!memcmp(sig, signature, 12) &&
>      (leaves == 0 || ((eax - base) >= leaves)))
>   return base;
> }
>
> return 0;
>}
>
>extern unsigned long arch_align_stack(unsigned long sp);
>void free_init_pages(const char *what, unsigned long begin, unsigned long end);
>extern void free_kernel_image_pages(const char *what, void *begin, void *end);
>
>void default_idle(void);
>
>bool xen_set_default_idle(void);
>
>
>
>
>void stop_this_cpu(void *dummy);
>void microcode_check(void);
>
>enum l1tf_mitigations {
> L1TF_MITIGATION_OFF,
> L1TF_MITIGATION_FLUSH_NOWARN,
> L1TF_MITIGATION_FLUSH,
> L1TF_MITIGATION_FLUSH_NOSMT,
> L1TF_MITIGATION_FULL,
> L1TF_MITIGATION_FULL_FORCE
>};
>
>extern enum l1tf_mitigations l1tf_mitigation;
>
>enum mds_mitigations {
> MDS_MITIGATION_OFF,
> MDS_MITIGATION_FULL,
> MDS_MITIGATION_VMWERV,
>};
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeature.h" 2
>
>
>
>
>
>
>
>enum cpuid_leafs
>{
> CPUID_1_EDX = 0,
> CPUID_8000_0001_EDX,
> CPUID_8086_0001_EDX,
> CPUID_LNX_1,
> CPUID_1_ECX,
> CPUID_C000_0001_EDX,
> CPUID_8000_0001_ECX,
> CPUID_LNX_2,
> CPUID_LNX_3,
> CPUID_7_0_EBX,
> CPUID_D_1_EAX,
> CPUID_LNX_4,
> CPUID_7_1_EAX,
> CPUID_8000_0008_EBX,
> CPUID_6_EAX,
> CPUID_8000_000A_EDX,
> CPUID_7_ECX,
> CPUID_8000_0007_EBX,
> CPUID_7_EDX,
> CPUID_8000_001F_EAX,
>};
>
>
>extern const char * const x86_cap_flags[22*32];
>extern const char * const x86_power_flags[32];
># 51 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeature.h"
>extern const char * const x86_bug_flags[1*32];
># 145 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeature.h"
>extern void setup_clear_cpu_cap(unsigned int bit);
>extern void clear_cpu_cap(struct cpuinfo_x86 *c, unsigned int bit);
># 177 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeature.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool _static_cpu_has(u16 bit)
>{
> do { asm goto("# ALT: oldinstr2\n" "661:\n\t" "jmp 6f" "\n662:\n" "# ALT: padding2\n" ".skip -((" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")) > 0) * " "(" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")), 0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 3*32+21)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" " .long 661b - .\n" " .long " "664""2""f - .\n" " .word " "%P[feature]" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""2""f-""664""2""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "jmp %l[t_no]" "\n" "665""1" ":\n" "# ALT: replacement " "2" "\n" "664""2"":\n\t" "" "\n" "665""2" ":\n" ".popsection\n" ".section .altinstr_aux,\"ax\"\n" "6:\n" " testb %[bitnum],%[cap_byte]\n" " jnz %l[t_yes]\n" " jmp %l[t_no]\n" ".previous\n" : : [feature] "i" (bit), [bitnum] "i" (1 << (bit & 7)), [cap_byte] "m" (((const char *)boot_cpu_data.x86_capability)[bit >> 3]) : : t_yes, t_no); asm (""); } while (0)
># 190 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cpufeature.h"
>                   ;
>t_yes:
> return true;
>t_no:
> return false;
>}
># 54 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h" 2
>
>
>struct thread_info {
> unsigned long flags;
> unsigned long syscall_work;
> u32 status;
>};
># 164 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_within_stack_frames(const void * const stack,
>        const void * const stackend,
>        const void *obj, unsigned long len)
>{
># 196 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h"
> return NOT_STACK;
>
>}
># 227 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/thread_info.h"
>extern void arch_task_cache_init(void);
>extern int arch_dup_task_struct(struct task_struct *dst, struct task_struct *src);
>extern void arch_release_task_struct(struct task_struct *tsk);
>extern void arch_setup_new_exec(void);
># 61 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h" 2
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long set_restart_fn(struct restart_block *restart,
>     long (*fn)(struct restart_block *))
>{
> restart->fn = fn;
> do { restart->arch_data = ((struct thread_info *)get_current())->status; } while (0);
> return -516;
>}
># 87 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_ti_thread_flag(struct thread_info *ti, int flag)
>{
> set_bit(flag, (unsigned long *)&ti->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_ti_thread_flag(struct thread_info *ti, int flag)
>{
> clear_bit(flag, (unsigned long *)&ti->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_ti_thread_flag(struct thread_info *ti, int flag,
>      bool value)
>{
> if (value)
>  set_ti_thread_flag(ti, flag);
> else
>  clear_ti_thread_flag(ti, flag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_and_set_ti_thread_flag(struct thread_info *ti, int flag)
>{
> return test_and_set_bit(flag, (unsigned long *)&ti->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_and_clear_ti_thread_flag(struct thread_info *ti, int flag)
>{
> return test_and_clear_bit(flag, (unsigned long *)&ti->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_ti_thread_flag(struct thread_info *ti, int flag)
>{
> return test_bit(flag, (unsigned long *)&ti->flags);
>}
># 188 "/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void check_object_size(const void *ptr, unsigned long n,
>         bool to_user)
>{ }
>
>
>extern void __attribute__((__error__("copy source size is too small")))
>__bad_copy_from(void);
>extern void __attribute__((__error__("copy destination size is too small")))
>__bad_copy_to(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void copy_overflow(int size, unsigned long count)
>{
> ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("Buffer overflow detected (%d < %lu)!\n", size, count); do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"), "i" (200), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("60" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "60" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) bool
>check_copy_size(const void *addr, size_t bytes, bool is_source)
>{
> int sz = __builtin_object_size(addr, 0);
> if (__builtin_expect(!!(sz >= 0 && sz < bytes), 0)) {
>  if (!__builtin_constant_p(bytes))
>   copy_overflow(sz, bytes);
>  else if (is_source)
>   __bad_copy_from();
>  else
>   __bad_copy_to();
>  return false;
> }
> if (({ int __ret_warn_on = !!(bytes > ((int)(~0U >> 1))); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/thread_info.h"), "i" (216), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("61" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "61" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }))
>  return false;
> check_object_size(addr, bytes, is_source);
> return true;
>}
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/preempt.h" 2
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope___preempt_count; extern __attribute__((section(".data..percpu" ""))) __typeof__(int) __preempt_count;
># 25 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/preempt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int preempt_count(void)
>{
> return ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (__preempt_count)); (typeof(__preempt_count))(unsigned long) pfo_val__; }) & ~0x80000000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void preempt_count_set(int pc)
>{
> int old, new;
>
> do {
>  old = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (__preempt_count)); (typeof(__preempt_count))(unsigned long) pfo_val__; });
>  new = (old & 0x80000000) |
>   (pc & ~0x80000000);
> } while (({ u32 pco_old__ = ((u32)(((unsigned long) old) & 0xffffffff)); u32 pco_new__ = ((u32)(((unsigned long) new) & 0xffffffff)); asm ("cmpxchg" "l " "%[nval]" ", " "%%""gs"":" "%" "[var]" : [oval] "+a" (pco_old__), [var] "+m" (__preempt_count) : [nval] "r" (pco_new__) : "memory"); (typeof(__preempt_count))(unsigned long) pco_old__; }) != old);
>}
># 59 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/preempt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void set_preempt_need_resched(void)
>{
> do { u32 pto_val__ = ((u32)(((unsigned long) ~0x80000000) & 0xffffffff)); if (0) { typeof((__preempt_count)) pto_tmp__; pto_tmp__ = (~0x80000000); (void)pto_tmp__; } asm ("and" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count)) : [val] "ri" (pto_val__)); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void clear_preempt_need_resched(void)
>{
> do { u32 pto_val__ = ((u32)(((unsigned long) 0x80000000) & 0xffffffff)); if (0) { typeof((__preempt_count)) pto_tmp__; pto_tmp__ = (0x80000000); (void)pto_tmp__; } asm ("or" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count)) : [val] "ri" (pto_val__)); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool test_preempt_need_resched(void)
>{
> return !(({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (__preempt_count)); (typeof(__preempt_count))(unsigned long) pfo_val__; }) & 0x80000000);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __preempt_count_add(int val)
>{
> do { const int pao_ID__ = (__builtin_constant_p(val) && ((val) == 1 || (val) == -1)) ? (int)(val) : 0; if (0) { typeof((__preempt_count)) pao_tmp__; pao_tmp__ = (val); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) val) & 0xffffffff)); if (0) { typeof((__preempt_count)) pto_tmp__; pto_tmp__ = (val); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __preempt_count_sub(int val)
>{
> do { const int pao_ID__ = (__builtin_constant_p(-val) && ((-val) == 1 || (-val) == -1)) ? (int)(-val) : 0; if (0) { typeof((__preempt_count)) pao_tmp__; pao_tmp__ = (-val); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) -val) & 0xffffffff)); if (0) { typeof((__preempt_count)) pto_tmp__; pto_tmp__ = (-val); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((__preempt_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool __preempt_count_dec_and_test(void)
>{
> return ({ bool c; asm volatile ("decl" " " "%%""gs"":" "%" "[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (__preempt_count), "=@cc" "e" (c) : : "memory"); c; });
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool should_resched(int preempt_offset)
>{
> return __builtin_expect(!!(({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (__preempt_count)); (typeof(__preempt_count))(unsigned long) pfo_val__; }) == preempt_offset), 0);
>}
>
>
>
>extern void preempt_schedule(void);
>extern void preempt_schedule_thunk(void);
>
>
>
>extern void preempt_schedule_notrace(void);
>extern void preempt_schedule_notrace_thunk(void);
>
>
>
>
>
>extern struct static_call_key __SCK__preempt_schedule; extern struct static_call_tramp __SCT__preempt_schedule; extern typeof(preempt_schedule_thunk) __SCtype__preempt_schedule;
>
>
>
>
>
>
>
>extern struct static_call_key __SCK__preempt_schedule_notrace; extern struct static_call_tramp __SCT__preempt_schedule_notrace; extern typeof(preempt_schedule_notrace_thunk) __SCtype__preempt_schedule_notrace;
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h" 2
># 288 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h"
>struct preempt_notifier;
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h"
>struct preempt_ops {
> void (*sched_in)(struct preempt_notifier *notifier, int cpu);
> void (*sched_out)(struct preempt_notifier *notifier,
>     struct task_struct *next);
>};
># 317 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h"
>struct preempt_notifier {
> struct hlist_node link;
> struct preempt_ops *ops;
>};
>
>void preempt_notifier_inc(void);
>void preempt_notifier_dec(void);
>void preempt_notifier_register(struct preempt_notifier *notifier);
>void preempt_notifier_unregister(struct preempt_notifier *notifier);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void preempt_notifier_init(struct preempt_notifier *notifier,
>         struct preempt_ops *ops)
>{
> INIT_HLIST_NODE(&notifier->link);
> notifier->ops = ops;
>}
># 393 "/usr/src/linux-5.14.21-150500.53/include/linux/preempt.h"
>extern void migrate_disable(void);
>extern void migrate_enable(void);
># 56 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bottom_half.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/bottom_half.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __local_bh_disable_ip(unsigned long ip, unsigned int cnt)
>{
> __preempt_count_add(cnt);
> __asm__ __volatile__("": : :"memory");
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_bh_disable(void)
>{
> __local_bh_disable_ip(({ __label__ __here; __here: (unsigned long)&&__here; }), (2 * (1UL << (0 + 8))));
>}
>
>extern void _local_bh_enable(void);
>extern void __local_bh_enable_ip(unsigned long ip, unsigned int cnt);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_bh_enable_ip(unsigned long ip)
>{
> __local_bh_enable_ip(ip, (2 * (1UL << (0 + 8))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_bh_enable(void)
>{
> __local_bh_enable_ip(({ __label__ __here; __here: (unsigned long)&&__here; }), (2 * (1UL << (0 + 8))));
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool local_bh_blocked(void) { return false; }
># 63 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/smp_types.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/llist.h" 1
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/llist.h"
>struct llist_head {
> struct llist_node *first;
>};
>
>struct llist_node {
> struct llist_node *next;
>};
># 69 "/usr/src/linux-5.14.21-150500.53/include/linux/llist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_llist_head(struct llist_head *list)
>{
> list->first = ((void *)0);
>}
># 187 "/usr/src/linux-5.14.21-150500.53/include/linux/llist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool llist_empty(const struct llist_head *head)
>{
> return ({ do { extern void __compiletime_assert_62(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(head->first) == sizeof(char) || sizeof(head->first) == sizeof(short) || sizeof(head->first) == sizeof(int) || sizeof(head->first) == sizeof(long)) || sizeof(head->first) == sizeof(long long))) __compiletime_assert_62(); } while (0); (*(const volatile typeof( _Generic((head->first), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head->first))) *)&(head->first)); }) == ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct llist_node *llist_next(struct llist_node *node)
>{
> return node->next;
>}
>
>extern bool llist_add_batch(struct llist_node *new_first,
>       struct llist_node *new_last,
>       struct llist_head *head);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __llist_add_batch(struct llist_node *new_first,
>         struct llist_node *new_last,
>         struct llist_head *head)
>{
> new_last->next = head->first;
> head->first = new_first;
> return new_last->next == ((void *)0);
>}
># 217 "/usr/src/linux-5.14.21-150500.53/include/linux/llist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool llist_add(struct llist_node *new, struct llist_head *head)
>{
> return llist_add_batch(new, new, head);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __llist_add(struct llist_node *new, struct llist_head *head)
>{
> return __llist_add_batch(new, new, head);
>}
># 235 "/usr/src/linux-5.14.21-150500.53/include/linux/llist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct llist_node *llist_del_all(struct llist_head *head)
>{
> return ({ typeof(&head->first) __ai_ptr = (&head->first); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__ (*((__ai_ptr))) __ret = ((((void *)0))); switch (sizeof(*((__ai_ptr)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct llist_node *__llist_del_all(struct llist_head *head)
>{
> struct llist_node *first = head->first;
>
> head->first = ((void *)0);
> return first;
>}
>
>extern struct llist_node *llist_del_first(struct llist_head *head);
>
>struct llist_node *llist_reverse_order(struct llist_node *head);
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/smp_types.h" 2
>
>enum {
> CSD_FLAG_LOCK = 0x01,
>
> IRQ_WORK_PENDING = 0x01,
> IRQ_WORK_BUSY = 0x02,
> IRQ_WORK_LAZY = 0x04,
> IRQ_WORK_HARD_IRQ = 0x08,
>
> IRQ_WORK_CLAIMED = (IRQ_WORK_PENDING | IRQ_WORK_BUSY),
>
> CSD_TYPE_ASYNC = 0x00,
> CSD_TYPE_SYNC = 0x10,
> CSD_TYPE_IRQ_WORK = 0x20,
> CSD_TYPE_TTWU = 0x30,
>
> CSD_FLAG_TYPE_MASK = 0xF0,
>};
># 58 "/usr/src/linux-5.14.21-150500.53/include/linux/smp_types.h"
>struct __call_single_node {
> struct llist_node llist;
> union {
>  unsigned int u_flags;
>  atomic_t a_flags;
> };
>
> u16 src, dst;
>
>};
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h" 2
>
>typedef void (*smp_call_func_t)(void *info);
>typedef bool (*smp_cond_func_t)(int cpu, void *info);
>
>
>
>
>struct __call_single_data {
> struct __call_single_node node;
> smp_call_func_t func;
> void *info;
>};
>
>
>
>
>
>typedef struct __call_single_data call_single_data_t
> __attribute__((__aligned__(sizeof(struct __call_single_data))));
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h"
>extern void __smp_call_single_queue(int cpu, struct llist_node *node);
>
>
>extern unsigned int total_cpus;
>
>int smp_call_function_single(int cpuid, smp_call_func_t func, void *info,
>        int wait);
>
>void on_each_cpu_cond_mask(smp_cond_func_t cond_func, smp_call_func_t func,
>      void *info, bool wait, const struct cpumask *mask);
>
>int smp_call_function_single_async(int cpu, struct __call_single_data *csd);
>
>
>
>
>
>void panic_smp_self_stop(void);
>void nmi_panic_self_stop(struct pt_regs *regs);
>void crash_smp_send_stop(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void on_each_cpu(smp_call_func_t func, void *info, int wait)
>{
> on_each_cpu_cond_mask(((void *)0), func, info, wait, ((const struct cpumask *)&__cpu_online_mask));
>}
># 90 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void on_each_cpu_mask(const struct cpumask *mask,
>        smp_call_func_t func, void *info, bool wait)
>{
> on_each_cpu_cond_mask(((void *)0), func, info, wait, mask);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void on_each_cpu_cond(smp_cond_func_t cond_func,
>        smp_call_func_t func, void *info, bool wait)
>{
> on_each_cpu_cond_mask(cond_func, func, info, wait, ((const struct cpumask *)&__cpu_online_mask));
>}
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/smp.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/smp.h"
>extern int smp_num_siblings;
>extern unsigned int num_processors;
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_sibling_map; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(cpumask_var_t) cpu_sibling_map;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_core_map; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(cpumask_var_t) cpu_core_map;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_die_map; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(cpumask_var_t) cpu_die_map;
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_llc_shared_map; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(cpumask_var_t) cpu_llc_shared_map;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_l2c_shared_map; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(cpumask_var_t) cpu_l2c_shared_map;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_llc_id; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(u16) cpu_llc_id;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_l2c_id; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(u16) cpu_l2c_id;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_number; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(int) cpu_number;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cpumask *cpu_llc_shared_mask(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(cpu_llc_shared_map)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(cpu_llc_shared_map)))) *)((&(cpu_llc_shared_map))))); (typeof((typeof(*((&(cpu_llc_shared_map)))) *)((&(cpu_llc_shared_map))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cpumask *cpu_l2c_shared_mask(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(cpu_l2c_shared_map)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(cpu_l2c_shared_map)))) *)((&(cpu_l2c_shared_map))))); (typeof((typeof(*((&(cpu_l2c_shared_map)))) *)((&(cpu_l2c_shared_map))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_x86_cpu_to_apicid; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(u16) x86_cpu_to_apicid; extern __typeof__(u16) *x86_cpu_to_apicid_early_ptr; extern __typeof__(u16) x86_cpu_to_apicid_early_map[];
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_x86_cpu_to_acpiid; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(u32) x86_cpu_to_acpiid; extern __typeof__(u32) *x86_cpu_to_acpiid_early_ptr; extern __typeof__(u32) x86_cpu_to_acpiid_early_map[];
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_x86_bios_cpu_apicid; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(u16) x86_bios_cpu_apicid; extern __typeof__(u16) *x86_bios_cpu_apicid_early_ptr; extern __typeof__(u16) x86_bios_cpu_apicid_early_map[];
>
>
>
>
>struct task_struct;
>
>struct smp_ops {
> void (*smp_prepare_boot_cpu)(void);
> void (*smp_prepare_cpus)(unsigned max_cpus);
> void (*smp_cpus_done)(unsigned max_cpus);
>
> void (*stop_other_cpus)(int wait);
> void (*crash_stop_other_cpus)(void);
> void (*smp_send_reschedule)(int cpu);
>
> int (*cpu_up)(unsigned cpu, struct task_struct *tidle);
> int (*cpu_disable)(void);
> void (*cpu_die)(unsigned int cpu);
> void (*play_dead)(void);
>
> void (*send_call_func_ipi)(const struct cpumask *mask);
> void (*send_call_func_single_ipi)(int cpu);
> void *suse_kabi_padding;
>};
>
>
>extern void set_cpu_sibling_map(int cpu);
>
>
>extern struct smp_ops smp_ops;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void smp_send_stop(void)
>{
> smp_ops.stop_other_cpus(0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void stop_other_cpus(void)
>{
> smp_ops.stop_other_cpus(1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void smp_prepare_boot_cpu(void)
>{
> smp_ops.smp_prepare_boot_cpu();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void smp_prepare_cpus(unsigned int max_cpus)
>{
> smp_ops.smp_prepare_cpus(max_cpus);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void smp_cpus_done(unsigned int max_cpus)
>{
> smp_ops.smp_cpus_done(max_cpus);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __cpu_up(unsigned int cpu, struct task_struct *tidle)
>{
> return smp_ops.cpu_up(cpu, tidle);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __cpu_disable(void)
>{
> return smp_ops.cpu_disable();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __cpu_die(unsigned int cpu)
>{
> smp_ops.cpu_die(cpu);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void play_dead(void)
>{
> smp_ops.play_dead();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void smp_send_reschedule(int cpu)
>{
> smp_ops.smp_send_reschedule(cpu);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_send_call_function_single_ipi(int cpu)
>{
> smp_ops.send_call_func_single_ipi(cpu);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_send_call_function_ipi_mask(const struct cpumask *mask)
>{
> smp_ops.send_call_func_ipi(mask);
>}
>
>void cpu_disable_common(void);
>void native_smp_prepare_boot_cpu(void);
>void smp_prepare_cpus_common(void);
>void native_smp_prepare_cpus(unsigned int max_cpus);
>void calculate_max_logical_packages(void);
>void native_smp_cpus_done(unsigned int max_cpus);
>int common_cpu_up(unsigned int cpunum, struct task_struct *tidle);
>int native_cpu_up(unsigned int cpunum, struct task_struct *tidle);
>int native_cpu_disable(void);
>int common_cpu_die(unsigned int cpu);
>void native_cpu_die(unsigned int cpu);
>void hlt_play_dead(void);
>void native_play_dead(void);
>void play_dead_common(void);
>void wbinvd_on_cpu(int cpu);
>int wbinvd_on_all_cpus(void);
>void cond_wakeup_cpu0(void);
>
>void native_smp_send_reschedule(int cpu);
>void native_send_call_func_ipi(const struct cpumask *mask);
>void native_send_call_func_single_ipi(int cpu);
>void x86_idle_thread_init(unsigned int cpu, struct task_struct *idle);
>
>void smp_store_boot_cpu_info(void);
>void smp_store_cpu_info(int id);
>
> __attribute__((__externally_visible__)) void smp_reboot_interrupt(void);
>__attribute__((__externally_visible__)) void smp_reschedule_interrupt(struct pt_regs *regs);
>__attribute__((__externally_visible__)) void smp_call_function_interrupt(struct pt_regs *regs);
>__attribute__((__externally_visible__)) void smp_call_function_single_interrupt(struct pt_regs *r);
># 185 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/smp.h"
>extern unsigned disabled_cpus;
>
>
>extern int hard_smp_processor_id(void);
># 115 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h" 2
># 124 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h"
>extern void smp_send_stop(void);
>
>
>
>
>extern void smp_send_reschedule(int cpu);
>
>
>
>
>
>extern void smp_prepare_cpus(unsigned int max_cpus);
>
>
>
>
>extern int __cpu_up(unsigned int cpunum, struct task_struct *tidle);
>
>
>
>
>extern void smp_cpus_done(unsigned int max_cpus);
>
>
>
>
>void smp_call_function(smp_call_func_t func, void *info, int wait);
>void smp_call_function_many(const struct cpumask *mask,
>       smp_call_func_t func, void *info, bool wait);
>
>int smp_call_function_any(const struct cpumask *mask,
>     smp_call_func_t func, void *info, int wait);
>
>void kick_all_cpus_sync(void);
>void wake_up_all_idle_cpus(void);
>
>
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) call_function_init(void);
>void generic_smp_call_function_single_interrupt(void);
>
>
>
>
>
>
>
>void smp_prepare_boot_cpu(void);
>
>extern unsigned int setup_max_cpus;
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) setup_nr_cpu_ids(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) smp_init(void);
>
>extern int __boot_cpu_id;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_boot_cpu_id(void)
>{
> return __boot_cpu_id;
>}
># 275 "/usr/src/linux-5.14.21-150500.53/include/linux/smp.h"
>extern void arch_disable_smp_support(void);
>
>extern void arch_thaw_secondary_cpus_begin(void);
>extern void arch_thaw_secondary_cpus_end(void);
>
>void smp_setup_processor_id(void);
>
>int smp_call_on_cpu(unsigned int cpu, int (*func)(void *), void *par,
>      bool phys);
>
>
>int smpcfd_prepare_cpu(unsigned int cpu);
>int smpcfd_dead_cpu(unsigned int cpu);
>int smpcfd_dying_cpu(unsigned int cpu);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h" 2
>
>
>struct task_struct;
>
>
>extern int prove_locking;
>extern int lock_stat;
># 345 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_init_task(struct task_struct *task)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_off(void)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_on(void)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_set_selftest_task(struct task_struct *task)
>{
>}
># 394 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_register_key(struct lock_class_key *key)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_unregister_key(struct lock_class_key *key)
>{
>}
>
>
>
>
>
>
>
>extern int lock_is_held(const void *);
>extern int lockdep_is_held(const void *);
># 432 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
>enum xhlock_context_t {
> XHLOCK_HARD,
> XHLOCK_SOFT,
> XHLOCK_CTX_NR,
>};
># 446 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_invariant_state(bool force) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_free_task(struct task_struct *task) {}
># 491 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void print_irqtrace_events(struct task_struct *curr)
>{
>}
># 659 "/usr/src/linux-5.14.21-150500.53/include/linux/lockdep.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>lockdep_rcu_suspicious(const char *file, const int line, const char *s)
>{
>}
># 64 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
>
># 1 "./arch/x86/include/generated/asm/mmiowb.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/mmiowb.h" 1
># 1 "./arch/x86/include/generated/asm/mmiowb.h" 2
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
># 94 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock.h" 1
># 27 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qspinlock.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qspinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u32 queued_fetch_set_pending_acquire(struct qspinlock *lock)
>{
> u32 val;
>
>
>
>
>
>
> val = ({ bool c; asm volatile (".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "btsl" " %[val], " "%[var]" "\n\t/* output condition code " "c" "*/\n" : [var] "+m" (lock->val.counter), "=@cc" "c" (c) : [val] "I" ((0 + 8)) : "memory"); c; })
>                                  * (1U << (0 + 8));
> val |= atomic_read(&lock->val) & ~(((1U << 8) - 1) << (0 + 8));
>
> return val;
>}
>
>
>extern void native_queued_spin_lock_slowpath(struct qspinlock *lock, u32 val);
>extern void __pv_init_lock_hash(void);
>extern void __pv_queued_spin_lock_slowpath(struct qspinlock *lock, u32 val);
>extern void __raw_callee_save___pv_queued_spin_unlock(struct qspinlock *lock);
>extern bool nopvspin;
># 44 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qspinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_queued_spin_unlock(struct qspinlock *lock)
>{
> do { do { extern void __compiletime_assert_63(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&lock->locked) == sizeof(char) || sizeof(*&lock->locked) == sizeof(short) || sizeof(*&lock->locked) == sizeof(int) || sizeof(*&lock->locked) == sizeof(long)))) __compiletime_assert_63(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_64(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&lock->locked) == sizeof(char) || sizeof(*&lock->locked) == sizeof(short) || sizeof(*&lock->locked) == sizeof(int) || sizeof(*&lock->locked) == sizeof(long)) || sizeof(*&lock->locked) == sizeof(long long))) __compiletime_assert_64(); } while (0); do { *(volatile typeof(*&lock->locked) *)&(*&lock->locked) = (0); } while (0); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queued_spin_lock_slowpath(struct qspinlock *lock, u32 val)
>{
> pv_queued_spin_lock_slowpath(lock, val);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queued_spin_unlock(struct qspinlock *lock)
>{
> pv_queued_spin_unlock(lock);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vcpu_is_preempted(long cpu)
>{
> return pv_vcpu_is_preempted(cpu);
>}
># 74 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qspinlock.h"
>extern struct static_key_true virt_spin_lock_key;
>
>void native_pv_lock_init(void) __attribute__((__section__(".init.text"))) __attribute__((__cold__)) ;
># 87 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qspinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool virt_spin_lock(struct qspinlock *lock)
>{
> if (!({ bool branch; if (__builtin_types_compatible_p(typeof(*&virt_spin_lock_key), struct static_key_true)) branch = !arch_static_branch(&(&virt_spin_lock_key)->key, true); else if (__builtin_types_compatible_p(typeof(*&virt_spin_lock_key), struct static_key_false)) branch = !arch_static_branch_jump(&(&virt_spin_lock_key)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }))
>  return false;
>
>
>
>
>
>
>
> do {
>  while (atomic_read(&lock->val) != 0)
>   cpu_relax();
> } while (atomic_cmpxchg(&lock->val, 0, (1U << 0)) != 0);
>
> return true;
>}
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qspinlock.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qspinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int queued_spin_is_locked(struct qspinlock *lock)
>{
>
>
>
>
> return atomic_read(&lock->val);
>}
># 42 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qspinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int queued_spin_value_unlocked(struct qspinlock lock)
>{
> return !atomic_read(&lock.val);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int queued_spin_is_contended(struct qspinlock *lock)
>{
> return atomic_read(&lock->val) & ~(((1U << 8) - 1) << 0);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int queued_spin_trylock(struct qspinlock *lock)
>{
> int val = atomic_read(&lock->val);
>
> if (__builtin_expect(!!(val), 0))
>  return 0;
>
> return __builtin_expect(!!(atomic_try_cmpxchg_acquire(&lock->val, &val, (1U << 0))), 1);
>}
>
>extern void queued_spin_lock_slowpath(struct qspinlock *lock, u32 val);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void queued_spin_lock(struct qspinlock *lock)
>{
> int val = 0;
>
> if (__builtin_expect(!!(atomic_try_cmpxchg_acquire(&lock->val, &val, (1U << 0))), 1))
>  return;
>
> queued_spin_lock_slowpath(lock, val);
>}
># 112 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qspinlock.h" 2
># 28 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock.h" 2
># 43 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qrwlock.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qrwlock.h" 1
># 32 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/qrwlock.h"
>extern void queued_read_lock_slowpath(struct qrwlock *lock);
>extern void queued_write_lock_slowpath(struct qrwlock *lock);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int queued_read_trylock(struct qrwlock *lock)
>{
> int cnts;
>
> cnts = atomic_read(&lock->cnts);
> if (__builtin_expect(!!(!(cnts & 0x1ff)), 1)) {
>  cnts = (u32)atomic_add_return_acquire((1U << 9), &lock->cnts);
>  if (__builtin_expect(!!(!(cnts & 0x1ff)), 1))
>   return 1;
>  atomic_sub((1U << 9), &lock->cnts);
> }
> return 0;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int queued_write_trylock(struct qrwlock *lock)
>{
> int cnts;
>
> cnts = atomic_read(&lock->cnts);
> if (__builtin_expect(!!(cnts), 0))
>  return 0;
>
> return __builtin_expect(!!(atomic_try_cmpxchg_acquire(&lock->cnts, &cnts, 0x0ff)), 1)
>                ;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queued_read_lock(struct qrwlock *lock)
>{
> int cnts;
>
> cnts = atomic_add_return_acquire((1U << 9), &lock->cnts);
> if (__builtin_expect(!!(!(cnts & 0x1ff)), 1))
>  return;
>
>
> queued_read_lock_slowpath(lock);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queued_write_lock(struct qrwlock *lock)
>{
> int cnts = 0;
>
> if (__builtin_expect(!!(atomic_try_cmpxchg_acquire(&lock->cnts, &cnts, 0x0ff)), 1))
>  return;
>
> queued_write_lock_slowpath(lock);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queued_read_unlock(struct qrwlock *lock)
>{
>
>
>
> (void)atomic_sub_return_release((1U << 9), &lock->cnts);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queued_write_unlock(struct qrwlock *lock)
>{
> do { do { extern void __compiletime_assert_65(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&lock->wlocked) == sizeof(char) || sizeof(*&lock->wlocked) == sizeof(short) || sizeof(*&lock->wlocked) == sizeof(int) || sizeof(*&lock->wlocked) == sizeof(long)))) __compiletime_assert_65(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_66(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&lock->wlocked) == sizeof(char) || sizeof(*&lock->wlocked) == sizeof(short) || sizeof(*&lock->wlocked) == sizeof(int) || sizeof(*&lock->wlocked) == sizeof(long)) || sizeof(*&lock->wlocked) == sizeof(long long))) __compiletime_assert_66(); } while (0); do { *(volatile typeof(*&lock->wlocked) *)&(*&lock->wlocked) = (0); } while (0); } while (0); } while (0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int queued_rwlock_is_contended(struct qrwlock *lock)
>{
> return queued_spin_is_locked(&lock->wait_lock);
>}
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/qrwlock.h" 2
># 44 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/spinlock.h" 2
># 95 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
># 183 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_raw_spin_lock(raw_spinlock_t *lock)
>{
> (void)0;
> queued_spin_lock(&lock->raw_lock);
> do { } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int do_raw_spin_trylock(raw_spinlock_t *lock)
>{
> int ret = queued_spin_trylock(&(lock)->raw_lock);
>
> if (ret)
>  do { } while (0);
>
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_raw_spin_unlock(raw_spinlock_t *lock)
>{
> do { } while (0);
> queued_spin_unlock(&lock->raw_lock);
> (void)0;
>}
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock.h" 1
># 305 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_api_smp.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_api_smp.h"
>int in_lock_functions(unsigned long addr);
>
>
>
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock(raw_spinlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_nested(raw_spinlock_t *lock, int subclass)
>        ;
>void __attribute__((__section__(".spinlock.text")))
>_raw_spin_lock_nest_lock(raw_spinlock_t *lock, struct lockdep_map *map)
>        ;
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_bh(raw_spinlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_irq(raw_spinlock_t *lock)
>        ;
>
>unsigned long __attribute__((__section__(".spinlock.text"))) _raw_spin_lock_irqsave(raw_spinlock_t *lock)
>        ;
>unsigned long __attribute__((__section__(".spinlock.text")))
>_raw_spin_lock_irqsave_nested(raw_spinlock_t *lock, int subclass)
>        ;
>int __attribute__((__section__(".spinlock.text"))) _raw_spin_trylock(raw_spinlock_t *lock);
>int __attribute__((__section__(".spinlock.text"))) _raw_spin_trylock_bh(raw_spinlock_t *lock);
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_unlock(raw_spinlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_unlock_bh(raw_spinlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_spin_unlock_irq(raw_spinlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text")))
>_raw_spin_unlock_irqrestore(raw_spinlock_t *lock, unsigned long flags)
>        ;
># 86 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_api_smp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __raw_spin_trylock(raw_spinlock_t *lock)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> if (do_raw_spin_trylock(lock)) {
>  do { } while (0);
>  return 1;
> }
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
> return 0;
>}
># 104 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_api_smp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __raw_spin_lock_irqsave(raw_spinlock_t *lock)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do_raw_spin_lock(lock);
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_lock_irq(raw_spinlock_t *lock)
>{
> do { arch_local_irq_disable(); } while (0);
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do_raw_spin_lock(lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_lock_bh(raw_spinlock_t *lock)
>{
> __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
> do { } while (0);
> do_raw_spin_lock(lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_lock(raw_spinlock_t *lock)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do_raw_spin_lock(lock);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_unlock(raw_spinlock_t *lock)
>{
> do { } while (0);
> do_raw_spin_unlock(lock);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_unlock_irqrestore(raw_spinlock_t *lock,
>         unsigned long flags)
>{
> do { } while (0);
> do_raw_spin_unlock(lock);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_unlock_irq(raw_spinlock_t *lock)
>{
> do { } while (0);
> do_raw_spin_unlock(lock);
> do { arch_local_irq_enable(); } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_spin_unlock_bh(raw_spinlock_t *lock)
>{
> do { } while (0);
> do_raw_spin_unlock(lock);
> __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __raw_spin_trylock_bh(raw_spinlock_t *lock)
>{
> __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
> if (do_raw_spin_trylock(lock)) {
>  do { } while (0);
>  return 1;
> }
> __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
> return 0;
>}
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock_api_smp.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock_api_smp.h"
>void __attribute__((__section__(".spinlock.text"))) _raw_read_lock(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_lock(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_lock_nested(rwlock_t *lock, int subclass) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_read_lock_bh(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_lock_bh(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_read_lock_irq(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_lock_irq(rwlock_t *lock) ;
>unsigned long __attribute__((__section__(".spinlock.text"))) _raw_read_lock_irqsave(rwlock_t *lock)
>       ;
>unsigned long __attribute__((__section__(".spinlock.text"))) _raw_write_lock_irqsave(rwlock_t *lock)
>       ;
>int __attribute__((__section__(".spinlock.text"))) _raw_read_trylock(rwlock_t *lock);
>int __attribute__((__section__(".spinlock.text"))) _raw_write_trylock(rwlock_t *lock);
>void __attribute__((__section__(".spinlock.text"))) _raw_read_unlock(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_unlock(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_read_unlock_bh(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_unlock_bh(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_read_unlock_irq(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text"))) _raw_write_unlock_irq(rwlock_t *lock) ;
>void __attribute__((__section__(".spinlock.text")))
>_raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
>       ;
>void __attribute__((__section__(".spinlock.text")))
>_raw_write_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
>       ;
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock_api_smp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __raw_read_trylock(rwlock_t *lock)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> if (queued_read_trylock(&(lock)->raw_lock)) {
>  do { if (0) do { } while (0); else do { } while (0); } while (0);
>  return 1;
> }
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __raw_write_trylock(rwlock_t *lock)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> if (queued_write_trylock(&(lock)->raw_lock)) {
>  do { } while (0);
>  return 1;
> }
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
> return 0;
>}
># 147 "/usr/src/linux-5.14.21-150500.53/include/linux/rwlock_api_smp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_read_lock(rwlock_t *lock)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { if (0) do { } while (0); else do { } while (0); } while (0);
> do {(void)0; queued_read_lock(&(lock)->raw_lock); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __raw_read_lock_irqsave(rwlock_t *lock)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { if (0) do { } while (0); else do { } while (0); } while (0);
> do {(void)0; queued_read_lock(&(lock)->raw_lock); } while (0);
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_read_lock_irq(rwlock_t *lock)
>{
> do { arch_local_irq_disable(); } while (0);
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { if (0) do { } while (0); else do { } while (0); } while (0);
> do {(void)0; queued_read_lock(&(lock)->raw_lock); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_read_lock_bh(rwlock_t *lock)
>{
> __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
> do { if (0) do { } while (0); else do { } while (0); } while (0);
> do {(void)0; queued_read_lock(&(lock)->raw_lock); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __raw_write_lock_irqsave(rwlock_t *lock)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do {(void)0; queued_write_lock(&(lock)->raw_lock); } while (0);
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_lock_irq(rwlock_t *lock)
>{
> do { arch_local_irq_disable(); } while (0);
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do {(void)0; queued_write_lock(&(lock)->raw_lock); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_lock_bh(rwlock_t *lock)
>{
> __local_bh_disable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
> do { } while (0);
> do {(void)0; queued_write_lock(&(lock)->raw_lock); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_lock(rwlock_t *lock)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do {(void)0; queued_write_lock(&(lock)->raw_lock); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_lock_nested(rwlock_t *lock, int subclass)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> do { } while (0);
> do {(void)0; queued_write_lock(&(lock)->raw_lock); } while (0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_unlock(rwlock_t *lock)
>{
> do { } while (0);
> do {queued_write_unlock(&(lock)->raw_lock); (void)0; } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_read_unlock(rwlock_t *lock)
>{
> do { } while (0);
> do {queued_read_unlock(&(lock)->raw_lock); (void)0; } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>__raw_read_unlock_irqrestore(rwlock_t *lock, unsigned long flags)
>{
> do { } while (0);
> do {queued_read_unlock(&(lock)->raw_lock); (void)0; } while (0);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_read_unlock_irq(rwlock_t *lock)
>{
> do { } while (0);
> do {queued_read_unlock(&(lock)->raw_lock); (void)0; } while (0);
> do { arch_local_irq_enable(); } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_read_unlock_bh(rwlock_t *lock)
>{
> do { } while (0);
> do {queued_read_unlock(&(lock)->raw_lock); (void)0; } while (0);
> __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_unlock_irqrestore(rwlock_t *lock,
>          unsigned long flags)
>{
> do { } while (0);
> do {queued_write_unlock(&(lock)->raw_lock); (void)0; } while (0);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_unlock_irq(rwlock_t *lock)
>{
> do { } while (0);
> do {queued_write_unlock(&(lock)->raw_lock); (void)0; } while (0);
> do { arch_local_irq_enable(); } while (0);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __raw_write_unlock_bh(rwlock_t *lock)
>{
> do { } while (0);
> do {queued_write_unlock(&(lock)->raw_lock); (void)0; } while (0);
> __local_bh_enable_ip((unsigned long)__builtin_return_address(0), ((2 * (1UL << (0 + 8))) + (1UL << 0)));
>}
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock_api_smp.h" 2
># 312 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h" 2
># 323 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) raw_spinlock_t *spinlock_check(spinlock_t *lock)
>{
> return &lock->rlock;
>}
># 348 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_lock(spinlock_t *lock)
>{
> _raw_spin_lock(&lock->rlock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_lock_bh(spinlock_t *lock)
>{
> _raw_spin_lock_bh(&lock->rlock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int spin_trylock(spinlock_t *lock)
>{
> return (_raw_spin_trylock(&lock->rlock));
>}
># 373 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_lock_irq(spinlock_t *lock)
>{
> _raw_spin_lock_irq(&lock->rlock);
>}
># 388 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_unlock(spinlock_t *lock)
>{
> _raw_spin_unlock(&lock->rlock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_unlock_bh(spinlock_t *lock)
>{
> _raw_spin_unlock_bh(&lock->rlock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_unlock_irq(spinlock_t *lock)
>{
> _raw_spin_unlock_irq(&lock->rlock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void spin_unlock_irqrestore(spinlock_t *lock, unsigned long flags)
>{
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _raw_spin_unlock_irqrestore(&lock->rlock, flags); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int spin_trylock_bh(spinlock_t *lock)
>{
> return (_raw_spin_trylock_bh(&lock->rlock));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int spin_trylock_irq(spinlock_t *lock)
>{
> return ({ do { arch_local_irq_disable(); } while (0); (_raw_spin_trylock(&lock->rlock)) ? 1 : ({ do { arch_local_irq_enable(); } while (0); 0; }); });
>}
># 441 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int spin_is_locked(spinlock_t *lock)
>{
> return queued_spin_is_locked(&(&lock->rlock)->raw_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int spin_is_contended(spinlock_t *lock)
>{
> return queued_spin_is_contended(&(&lock->rlock)->raw_lock);
>}
># 470 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>extern int _atomic_dec_and_lock(atomic_t *atomic, spinlock_t *lock);
>
>
>
>extern int _atomic_dec_and_lock_irqsave(atomic_t *atomic, spinlock_t *lock,
>     unsigned long *flags);
>
>
>
>int __alloc_bucket_spinlocks(spinlock_t **locks, unsigned int *lock_mask,
>        size_t max_size, unsigned int cpu_mult,
>        gfp_t gfp, const char *name,
>        struct lock_class_key *key);
># 494 "/usr/src/linux-5.14.21-150500.53/include/linux/spinlock.h"
>void free_bucket_spinlocks(spinlock_t *locks);
># 17 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-lock.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/semaphore.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/semaphore.h"
>struct semaphore {
> raw_spinlock_t lock;
> unsigned int count;
> struct list_head wait_list;
>};
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/semaphore.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sema_init(struct semaphore *sem, int val)
>{
> static struct lock_class_key __key;
> *sem = (struct semaphore) { .lock = (raw_spinlock_t) { .raw_lock = { { .val = { (0) } } }, }, .count = val, .wait_list = { &((*sem).wait_list), &((*sem).wait_list) }, };
> do { (void)("semaphore->lock"); (void)(&__key); } while (0);
>}
>
>extern void down(struct semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_interruptible(struct semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_killable(struct semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_trylock(struct semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_timeout(struct semaphore *sem, long jiffies);
>extern void up(struct semaphore *sem);
># 20 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-lock.h" 2
># 35 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-lock.h"
>typedef spinlock_t nv_spinlock_t;
># 20 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-pgprot.h" 1
># 17 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-pgprot.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mmdebug.h" 1
>
>
>
>
>
>
>
>struct page;
>struct vm_area_struct;
>struct mm_struct;
>
>void dump_page(struct page *page, const char *reason);
>void dump_vma(const struct vm_area_struct *vma);
>void dump_mm(const struct mm_struct *mm);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/wait.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h" 2
>
>typedef struct wait_queue_entry wait_queue_entry_t;
>
>typedef int (*wait_queue_func_t)(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key);
>int default_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int flags, void *key);
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>struct wait_queue_entry {
> unsigned int flags;
> void *private;
> wait_queue_func_t func;
> struct list_head entry;
>};
>
>struct wait_queue_head {
> spinlock_t lock;
> struct list_head head;
>};
>typedef struct wait_queue_head wait_queue_head_t;
>
>struct task_struct;
># 64 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>extern void __init_waitqueue_head(struct wait_queue_head *wq_head, const char *name, struct lock_class_key *);
># 82 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_waitqueue_entry(struct wait_queue_entry *wq_entry, struct task_struct *p)
>{
> wq_entry->flags = 0;
> wq_entry->private = p;
> wq_entry->func = default_wake_function;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>init_waitqueue_func_entry(struct wait_queue_entry *wq_entry, wait_queue_func_t func)
>{
> wq_entry->flags = 0;
> wq_entry->private = ((void *)0);
> wq_entry->func = func;
>}
># 127 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int waitqueue_active(struct wait_queue_head *wq_head)
>{
> return !list_empty(&wq_head->head);
>}
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool wq_has_single_sleeper(struct wait_queue_head *wq_head)
>{
> return list_is_singular(&wq_head->head);
>}
># 153 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool wq_has_sleeper(struct wait_queue_head *wq_head)
>{
>
>
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> return waitqueue_active(wq_head);
>}
>
>extern void add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
>extern void add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
>extern void add_wait_queue_priority(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
>extern void remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __add_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
>{
> struct list_head *head = &wq_head->head;
> struct wait_queue_entry *wq;
>
> for (wq = ({ void *__mptr = (void *)((&wq_head->head)->next); do { extern void __compiletime_assert_67(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*((&wq_head->head)->next)), typeof(((typeof(*wq) *)0)->entry)) && !__builtin_types_compatible_p(typeof(*((&wq_head->head)->next)), typeof(void))))) __compiletime_assert_67(); } while (0); ((typeof(*wq) *)(__mptr - __builtin_offsetof(typeof(*wq), entry))); }); !(&wq->entry == (&wq_head->head)); wq = ({ void *__mptr = (void *)((wq)->entry.next); do { extern void __compiletime_assert_68(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*((wq)->entry.next)), typeof(((typeof(*(wq)) *)0)->entry)) && !__builtin_types_compatible_p(typeof(*((wq)->entry.next)), typeof(void))))) __compiletime_assert_68(); } while (0); ((typeof(*(wq)) *)(__mptr - __builtin_offsetof(typeof(*(wq)), entry))); })) {
>  if (!(wq->flags & 0x20))
>   break;
>  head = &wq->entry;
> }
> list_add(&wq_entry->entry, head);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>__add_wait_queue_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
>{
> wq_entry->flags |= 0x01;
> __add_wait_queue(wq_head, wq_entry);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __add_wait_queue_entry_tail(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
>{
> list_add_tail(&wq_entry->entry, &wq_head->head);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>__add_wait_queue_entry_tail_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
>{
> wq_entry->flags |= 0x01;
> __add_wait_queue_entry_tail(wq_head, wq_entry);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>__remove_wait_queue(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry)
>{
> list_del(&wq_entry->entry);
>}
>
>void __wake_up(struct wait_queue_head *wq_head, unsigned int mode, int nr, void *key);
>void __wake_up_locked_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
>void __wake_up_locked_key_bookmark(struct wait_queue_head *wq_head,
>  unsigned int mode, void *key, wait_queue_entry_t *bookmark);
>void __wake_up_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
>void __wake_up_locked_sync_key(struct wait_queue_head *wq_head, unsigned int mode, void *key);
>void __wake_up_locked(struct wait_queue_head *wq_head, unsigned int mode, int nr);
>void __wake_up_sync(struct wait_queue_head *wq_head, unsigned int mode);
>void __wake_up_pollfree(struct wait_queue_head *wq_head);
># 261 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wake_up_pollfree(struct wait_queue_head *wq_head)
>{
>
>
>
>
>
>
>
> if (waitqueue_active(wq_head))
>  __wake_up_pollfree(wq_head);
>}
># 286 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>extern void init_wait_entry(struct wait_queue_entry *wq_entry, int flags);
># 770 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>extern int do_wait_intr(wait_queue_head_t *, wait_queue_entry_t *);
>extern int do_wait_intr_irq(wait_queue_head_t *, wait_queue_entry_t *);
># 1164 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>void prepare_to_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);
>bool prepare_to_wait_exclusive(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);
>long prepare_to_wait_event(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry, int state);
>void finish_wait(struct wait_queue_head *wq_head, struct wait_queue_entry *wq_entry);
>long wait_woken(struct wait_queue_entry *wq_entry, unsigned mode, long timeout);
>int woken_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);
>int autoremove_wake_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);
># 1189 "/usr/src/linux-5.14.21-150500.53/include/linux/wait.h"
>bool try_invoke_on_locked_down_task(struct task_struct *p, bool (*func)(struct task_struct *t, void *arg), void *arg);
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/numa.h" 1
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/numa.h"
>int numa_map_to_online_node(int node);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/osq_lock.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/osq_lock.h"
>struct optimistic_spin_node {
> struct optimistic_spin_node *next, *prev;
> int locked;
> int cpu;
>};
>
>struct optimistic_spin_queue {
>
>
>
>
> atomic_t tail;
>};
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void osq_lock_init(struct optimistic_spin_queue *lock)
>{
> atomic_set(&lock->tail, (0));
>}
>
>extern bool osq_lock(struct optimistic_spin_queue *lock);
>extern void osq_unlock(struct optimistic_spin_queue *lock);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool osq_is_locked(struct optimistic_spin_queue *lock)
>{
> return atomic_read(&lock->tail) != (0);
>}
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/debug_locks.h" 1
>
>
>
>
>
>
>
>struct task_struct;
>
>extern int debug_locks __attribute__((__section__(".data..read_mostly")));
>extern int debug_locks_silent __attribute__((__section__(".data..read_mostly")));
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int __debug_locks_off(void)
>{
> return ({ typeof(&debug_locks) __ai_ptr = (&debug_locks); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__ (*((__ai_ptr))) __ret = ((0)); switch (sizeof(*((__ai_ptr)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; }); });
>}
>
>
>
>
>extern int debug_locks_off(void);
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/debug_locks.h"
>struct task_struct;
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_show_all_locks(void)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_show_held_locks(struct task_struct *task)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_check_no_locks_freed(const void *from, unsigned long len)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_check_no_locks_held(void)
>{
>}
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h" 2
># 63 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h"
>struct mutex {
> atomic_long_t owner;
> raw_spinlock_t wait_lock;
>
> struct optimistic_spin_queue osq;
>
> struct list_head wait_list;
>
>
>
>
>
>
>};
># 89 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mutex_destroy(struct mutex *lock) {}
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h"
>extern void __mutex_init(struct mutex *lock, const char *name,
>    struct lock_class_key *key);
>
>
>
>
>
>
>
>extern bool mutex_is_locked(struct mutex *lock);
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h"
>extern void mutex_lock(struct mutex *lock);
>extern int __attribute__((__warn_unused_result__)) mutex_lock_interruptible(struct mutex *lock);
>extern int __attribute__((__warn_unused_result__)) mutex_lock_killable(struct mutex *lock);
>extern void mutex_lock_io(struct mutex *lock);
># 217 "/usr/src/linux-5.14.21-150500.53/include/linux/mutex.h"
>extern int mutex_trylock(struct mutex *lock);
>extern void mutex_unlock(struct mutex *lock);
>
>extern int atomic_dec_and_mutex_lock(atomic_t *cnt, struct mutex *lock);
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_types.h" 1
>
>
>
>
>struct rb_node {
> unsigned long __rb_parent_color;
> struct rb_node *rb_right;
> struct rb_node *rb_left;
>} __attribute__((aligned(sizeof(long))));
>
>
>struct rb_root {
> struct rb_node *rb_node;
>};
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_types.h"
>struct rb_root_cached {
> struct rb_root rb_root;
> struct rb_node *rb_leftmost;
>};
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h" 2
>
>
>extern int max_lock_depth;
>
>struct rt_mutex_base {
> raw_spinlock_t wait_lock;
> struct rb_root_cached waiters;
> struct task_struct *owner;
>};
># 42 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool rt_mutex_base_is_locked(struct rt_mutex_base *lock)
>{
> return ({ do { extern void __compiletime_assert_69(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(lock->owner) == sizeof(char) || sizeof(lock->owner) == sizeof(short) || sizeof(lock->owner) == sizeof(int) || sizeof(lock->owner) == sizeof(long)) || sizeof(lock->owner) == sizeof(long long))) __compiletime_assert_69(); } while (0); (*(const volatile typeof( _Generic((lock->owner), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (lock->owner))) *)&(lock->owner)); }) != ((void *)0);
>}
>
>extern void rt_mutex_base_init(struct rt_mutex_base *rtb);
># 57 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h"
>struct rt_mutex {
> struct rt_mutex_base rtmutex;
>
>
>
>};
>
>struct rt_mutex_waiter;
>struct hrtimer_sleeper;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rt_mutex_debug_task_free(struct task_struct *tsk) { }
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h"
>extern void __rt_mutex_init(struct rt_mutex *lock, const char *name, struct lock_class_key *key);
># 111 "/usr/src/linux-5.14.21-150500.53/include/linux/rtmutex.h"
>extern void rt_mutex_lock(struct rt_mutex *lock);
>
>
>
>
>extern int rt_mutex_lock_interruptible(struct rt_mutex *lock);
>extern int rt_mutex_lock_killable(struct rt_mutex *lock);
>extern int rt_mutex_trylock(struct rt_mutex *lock);
>
>extern void rt_mutex_unlock(struct rt_mutex *lock);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h" 2
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>struct ww_class {
> atomic_long_t stamp;
> struct lock_class_key acquire_key;
> struct lock_class_key mutex_key;
> const char *acquire_name;
> const char *mutex_name;
> unsigned int is_wait_die;
>};
>
>struct ww_mutex {
> struct mutex base;
> struct ww_acquire_ctx *ctx;
>
>
>
>};
>
>struct ww_acquire_ctx {
> struct task_struct *task;
> unsigned long stamp;
> unsigned int acquired;
> unsigned short wounded;
> unsigned short is_wait_die;
># 73 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>};
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ww_mutex_init(struct ww_mutex *lock,
>     struct ww_class *ww_class)
>{
> __mutex_init(&lock->base,ww_class->mutex_name,&ww_class->mutex_key);
> lock->ctx = ((void *)0);
>
>
>
>}
># 132 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ww_acquire_init(struct ww_acquire_ctx *ctx,
>       struct ww_class *ww_class)
>{
> ctx->task = get_current();
> ctx->stamp = atomic_long_inc_return_relaxed(&ww_class->stamp);
> ctx->acquired = 0;
> ctx->wounded = false;
> ctx->is_wait_die = ww_class->is_wait_die;
># 155 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>}
># 168 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ww_acquire_done(struct ww_acquire_ctx *ctx)
>{
>
>
>
>
>
>
>}
># 185 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ww_acquire_fini(struct ww_acquire_ctx *ctx)
>{
># 203 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>}
># 234 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>extern int ww_mutex_lock(struct ww_mutex *lock, struct ww_acquire_ctx *ctx);
># 266 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>extern int __attribute__((__warn_unused_result__)) ww_mutex_lock_interruptible(struct ww_mutex *lock,
>          struct ww_acquire_ctx *ctx);
># 292 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>ww_mutex_lock_slow(struct ww_mutex *lock, struct ww_acquire_ctx *ctx)
>{
> int ret;
>
>
>
> ret = ww_mutex_lock(lock, ctx);
> (void)ret;
>}
># 328 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__))
>ww_mutex_lock_slow_interruptible(struct ww_mutex *lock,
>     struct ww_acquire_ctx *ctx)
>{
>
>
>
> return ww_mutex_lock_interruptible(lock, ctx);
>}
>
>extern void ww_mutex_unlock(struct ww_mutex *lock);
>
>extern int __attribute__((__warn_unused_result__)) ww_mutex_trylock(struct ww_mutex *lock,
>      struct ww_acquire_ctx *ctx);
># 351 "/usr/src/linux-5.14.21-150500.53/include/linux/ww_mutex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ww_mutex_destroy(struct ww_mutex *lock)
>{
>
> mutex_destroy(&lock->base);
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ww_mutex_is_locked(struct ww_mutex *lock)
>{
> return mutex_is_locked((&lock->base));
>}
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h" 2
># 65 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>typedef struct seqcount {
> unsigned sequence;
>
>
>
>} seqcount_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __seqcount_init(seqcount_t *s, const char *name,
>       struct lock_class_key *key)
>{
>
>
>
> do { (void)(name); (void)(key); } while (0);
> s->sequence = 0;
>}
># 254 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) seqcount_t *__seqprop_ptr(seqcount_t *s)
>{
> return s;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned __seqprop_sequence(const seqcount_t *s)
>{
> return ({ do { extern void __compiletime_assert_70(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->sequence) == sizeof(char) || sizeof(s->sequence) == sizeof(short) || sizeof(s->sequence) == sizeof(int) || sizeof(s->sequence) == sizeof(long)) || sizeof(s->sequence) == sizeof(long long))) __compiletime_assert_70(); } while (0); (*(const volatile typeof( _Generic((s->sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->sequence))) *)&(s->sequence)); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __seqprop_preemptible(const seqcount_t *s)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __seqprop_assert(const seqcount_t *s)
>{
> do { } while (0);
>}
>
>
>
>typedef struct seqcount_raw_spinlock { seqcount_t seqcount; ; } seqcount_raw_spinlock_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) seqcount_t * __seqprop_raw_spinlock_ptr(seqcount_raw_spinlock_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned __seqprop_raw_spinlock_sequence(const seqcount_raw_spinlock_t *s) { unsigned seq = ({ do { extern void __compiletime_assert_71(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_71(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (false && __builtin_expect(!!(seq & 1), 0)) { ; ; seq = ({ do { extern void __compiletime_assert_72(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_72(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool __seqprop_raw_spinlock_preemptible(const seqcount_raw_spinlock_t *s) { if (!0) return false; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __seqprop_raw_spinlock_assert(const seqcount_raw_spinlock_t *s) { ; }
>typedef struct seqcount_spinlock { seqcount_t seqcount; ; } seqcount_spinlock_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) seqcount_t * __seqprop_spinlock_ptr(seqcount_spinlock_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned __seqprop_spinlock_sequence(const seqcount_spinlock_t *s) { unsigned seq = ({ do { extern void __compiletime_assert_73(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_73(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (0 && __builtin_expect(!!(seq & 1), 0)) { ; ; seq = ({ do { extern void __compiletime_assert_74(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_74(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool __seqprop_spinlock_preemptible(const seqcount_spinlock_t *s) { if (!0) return 0; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __seqprop_spinlock_assert(const seqcount_spinlock_t *s) { ; }
>typedef struct seqcount_rwlock { seqcount_t seqcount; ; } seqcount_rwlock_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) seqcount_t * __seqprop_rwlock_ptr(seqcount_rwlock_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned __seqprop_rwlock_sequence(const seqcount_rwlock_t *s) { unsigned seq = ({ do { extern void __compiletime_assert_75(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_75(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (0 && __builtin_expect(!!(seq & 1), 0)) { ; ; seq = ({ do { extern void __compiletime_assert_76(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_76(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool __seqprop_rwlock_preemptible(const seqcount_rwlock_t *s) { if (!0) return 0; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __seqprop_rwlock_assert(const seqcount_rwlock_t *s) { ; }
>typedef struct seqcount_mutex { seqcount_t seqcount; ; } seqcount_mutex_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) seqcount_t * __seqprop_mutex_ptr(seqcount_mutex_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned __seqprop_mutex_sequence(const seqcount_mutex_t *s) { unsigned seq = ({ do { extern void __compiletime_assert_77(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_77(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (true && __builtin_expect(!!(seq & 1), 0)) { ; ; seq = ({ do { extern void __compiletime_assert_78(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_78(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool __seqprop_mutex_preemptible(const seqcount_mutex_t *s) { if (!0) return true; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __seqprop_mutex_assert(const seqcount_mutex_t *s) { ; }
>typedef struct seqcount_ww_mutex { seqcount_t seqcount; ; } seqcount_ww_mutex_t; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) seqcount_t * __seqprop_ww_mutex_ptr(seqcount_ww_mutex_t *s) { return &s->seqcount; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned __seqprop_ww_mutex_sequence(const seqcount_ww_mutex_t *s) { unsigned seq = ({ do { extern void __compiletime_assert_79(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_79(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); if (!0) return seq; if (true && __builtin_expect(!!(seq & 1), 0)) { ; ; seq = ({ do { extern void __compiletime_assert_80(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_80(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); }); } return seq; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool __seqprop_ww_mutex_preemptible(const seqcount_ww_mutex_t *s) { if (!0) return true; return false; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __seqprop_ww_mutex_assert(const seqcount_ww_mutex_t *s) { ; }
># 430 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int do___read_seqcount_retry(const seqcount_t *s, unsigned start)
>{
> kcsan_atomic_next(0);
> return __builtin_expect(!!(({ do { extern void __compiletime_assert_81(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->sequence) == sizeof(char) || sizeof(s->sequence) == sizeof(short) || sizeof(s->sequence) == sizeof(int) || sizeof(s->sequence) == sizeof(long)) || sizeof(s->sequence) == sizeof(long long))) __compiletime_assert_81(); } while (0); (*(const volatile typeof( _Generic((s->sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->sequence))) *)&(s->sequence)); }) != start), 0);
>}
># 450 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int do_read_seqcount_retry(const seqcount_t *s, unsigned start)
>{
> __asm__ __volatile__("": : :"memory");
> return do___read_seqcount_retry(s, start);
>}
># 470 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_raw_write_seqcount_begin(seqcount_t *s)
>{
> kcsan_nestable_atomic_begin();
> s->sequence++;
> __asm__ __volatile__("": : :"memory");
>}
># 491 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_raw_write_seqcount_end(seqcount_t *s)
>{
> __asm__ __volatile__("": : :"memory");
> s->sequence++;
> kcsan_nestable_atomic_end();
>}
># 517 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_write_seqcount_begin_nested(seqcount_t *s, int subclass)
>{
> do_raw_write_seqcount_begin(s);
> do { } while (0);
>}
># 543 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_write_seqcount_begin(seqcount_t *s)
>{
> do_write_seqcount_begin_nested(s, 0);
>}
># 563 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_write_seqcount_end(seqcount_t *s)
>{
> do { } while (0);
> do_raw_write_seqcount_end(s);
>}
># 613 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_raw_write_seqcount_barrier(seqcount_t *s)
>{
> kcsan_nestable_atomic_begin();
> s->sequence++;
> __asm__ __volatile__("": : :"memory");
> s->sequence++;
> kcsan_nestable_atomic_end();
>}
># 633 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_write_seqcount_invalidate(seqcount_t *s)
>{
> __asm__ __volatile__("": : :"memory");
> kcsan_nestable_atomic_begin();
> s->sequence+=2;
> kcsan_nestable_atomic_end();
>}
># 651 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>typedef struct {
> seqcount_t seqcount;
>} seqcount_latch_t;
># 680 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned raw_read_seqcount_latch(const seqcount_latch_t *s)
>{
>
>
>
>
> return ({ do { extern void __compiletime_assert_82(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(s->seqcount.sequence) == sizeof(char) || sizeof(s->seqcount.sequence) == sizeof(short) || sizeof(s->seqcount.sequence) == sizeof(int) || sizeof(s->seqcount.sequence) == sizeof(long)) || sizeof(s->seqcount.sequence) == sizeof(long long))) __compiletime_assert_82(); } while (0); (*(const volatile typeof( _Generic((s->seqcount.sequence), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (s->seqcount.sequence))) *)&(s->seqcount.sequence)); });
>}
># 696 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>read_seqcount_latch_retry(const seqcount_latch_t *s, unsigned start)
>{
> return do_read_seqcount_retry(_Generic(*(&s->seqcount), seqcount_t: __seqprop_ptr((void *)(&s->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_ptr((void *)((&s->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_ptr((void *)((&s->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_ptr((void *)((&s->seqcount))), seqcount_mutex_t: __seqprop_mutex_ptr((void *)((&s->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_ptr((void *)((&s->seqcount)))), start);
>}
># 783 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void raw_write_seqcount_latch(seqcount_latch_t *s)
>{
> __asm__ __volatile__("": : :"memory");
> s->seqcount.sequence++;
> __asm__ __volatile__("": : :"memory");
>}
># 800 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>typedef struct {
>
>
>
>
> seqcount_spinlock_t seqcount;
> spinlock_t lock;
>} seqlock_t;
># 838 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned read_seqbegin(const seqlock_t *sl)
>{
> unsigned ret = ({ ; ({ unsigned _seq = ({ unsigned __seq; while ((__seq = _Generic(*(&sl->seqcount), seqcount_t: __seqprop_sequence((void *)(&sl->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_sequence((void *)((&sl->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_sequence((void *)((&sl->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_sequence((void *)((&sl->seqcount))), seqcount_mutex_t: __seqprop_mutex_sequence((void *)((&sl->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_sequence((void *)((&sl->seqcount))))) & 1) cpu_relax(); kcsan_atomic_next(1000); __seq; }); __asm__ __volatile__("": : :"memory"); _seq; }); });
>
> kcsan_atomic_next(0);
> kcsan_flat_atomic_begin();
> return ret;
>}
># 858 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned read_seqretry(const seqlock_t *sl, unsigned start)
>{
>
>
>
>
> kcsan_flat_atomic_end();
>
> return do_read_seqcount_retry(_Generic(*(&sl->seqcount), seqcount_t: __seqprop_ptr((void *)(&sl->seqcount)), seqcount_raw_spinlock_t: __seqprop_raw_spinlock_ptr((void *)((&sl->seqcount))), seqcount_spinlock_t: __seqprop_spinlock_ptr((void *)((&sl->seqcount))), seqcount_rwlock_t: __seqprop_rwlock_ptr((void *)((&sl->seqcount))), seqcount_mutex_t: __seqprop_mutex_ptr((void *)((&sl->seqcount))), seqcount_ww_mutex_t: __seqprop_ww_mutex_ptr((void *)((&sl->seqcount)))), start);
>}
># 888 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_seqlock(seqlock_t *sl)
>{
> spin_lock(&sl->lock);
> do_write_seqcount_begin(&sl->seqcount.seqcount);
>}
># 901 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_sequnlock(seqlock_t *sl)
>{
> do_write_seqcount_end(&sl->seqcount.seqcount);
> spin_unlock(&sl->lock);
>}
># 914 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_seqlock_bh(seqlock_t *sl)
>{
> spin_lock_bh(&sl->lock);
> do_write_seqcount_begin(&sl->seqcount.seqcount);
>}
># 928 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_sequnlock_bh(seqlock_t *sl)
>{
> do_write_seqcount_end(&sl->seqcount.seqcount);
> spin_unlock_bh(&sl->lock);
>}
># 941 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_seqlock_irq(seqlock_t *sl)
>{
> spin_lock_irq(&sl->lock);
> do_write_seqcount_begin(&sl->seqcount.seqcount);
>}
># 954 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_sequnlock_irq(seqlock_t *sl)
>{
> do_write_seqcount_end(&sl->seqcount.seqcount);
> spin_unlock_irq(&sl->lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __write_seqlock_irqsave(seqlock_t *sl)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&sl->lock)); } while (0); } while (0);
> do_write_seqcount_begin(&sl->seqcount.seqcount);
> return flags;
>}
># 991 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>write_sequnlock_irqrestore(seqlock_t *sl, unsigned long flags)
>{
> do_write_seqcount_end(&sl->seqcount.seqcount);
> spin_unlock_irqrestore(&sl->lock, flags);
>}
># 1014 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_seqlock_excl(seqlock_t *sl)
>{
> spin_lock(&sl->lock);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_sequnlock_excl(seqlock_t *sl)
>{
> spin_unlock(&sl->lock);
>}
># 1037 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_seqlock_excl_bh(seqlock_t *sl)
>{
> spin_lock_bh(&sl->lock);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_sequnlock_excl_bh(seqlock_t *sl)
>{
> spin_unlock_bh(&sl->lock);
>}
># 1061 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_seqlock_excl_irq(seqlock_t *sl)
>{
> spin_lock_irq(&sl->lock);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_sequnlock_excl_irq(seqlock_t *sl)
>{
> spin_unlock_irq(&sl->lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long __read_seqlock_excl_irqsave(seqlock_t *sl)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(spinlock_check(&sl->lock)); } while (0); } while (0);
> return flags;
>}
># 1104 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>read_sequnlock_excl_irqrestore(seqlock_t *sl, unsigned long flags)
>{
> spin_unlock_irqrestore(&sl->lock, flags);
>}
># 1141 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void read_seqbegin_or_lock(seqlock_t *lock, int *seq)
>{
> if (!(*seq & 1))
>  *seq = read_seqbegin(lock);
> else
>  read_seqlock_excl(lock);
>}
># 1156 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int need_seqretry(seqlock_t *lock, int seq)
>{
> return !(seq & 1) && read_seqretry(lock, seq);
>}
># 1169 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void done_seqretry(seqlock_t *lock, int seq)
>{
> if (seq & 1)
>  read_sequnlock_excl(lock);
>}
># 1195 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>read_seqbegin_or_lock_irqsave(seqlock_t *lock, int *seq)
>{
> unsigned long flags = 0;
>
> if (!(*seq & 1))
>  *seq = read_seqbegin(lock);
> else
>  do { flags = __read_seqlock_excl_irqsave(lock); } while (0);
>
> return flags;
>}
># 1220 "/usr/src/linux-5.14.21-150500.53/include/linux/seqlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>done_seqretry_irqrestore(seqlock_t *lock, int seq, unsigned long flags)
>{
> if (seq & 1)
>  read_sequnlock_excl_irqrestore(lock, flags);
>}
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h" 1
># 97 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/once.h" 1
>
>
>
>
>
>
>
>bool __do_once_start(bool *done, unsigned long *flags);
>void __do_once_done(bool *done, struct static_key_true *once_key,
>      unsigned long *flags, struct module *mod);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/random.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/random.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/irqnr.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/irqnr.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/irqnr.h" 2
>
>
>extern int nr_irqs;
>extern struct irq_desc *irq_to_desc(unsigned int irq);
>unsigned int irq_get_next_irq(unsigned int offset);
># 14 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/random.h" 2
># 41 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/random.h"
>struct rand_pool_info {
> int entropy_count;
> int buf_size;
> __u32 buf[0];
>};
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h" 2
>
>struct random_ready_callback {
> struct list_head list;
> void (*func)(struct random_ready_callback *rdy);
> struct module *owner;
>};
>
>extern void add_device_randomness(const void *, unsigned int);
>extern void add_bootloader_randomness(const void *, unsigned int);
># 29 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void add_latent_entropy(void) {}
>
>
>extern void add_input_randomness(unsigned int type, unsigned int code,
>     unsigned int value) ;
>extern void add_interrupt_randomness(int irq, int irq_flags) ;
>
>extern void get_random_bytes(void *buf, int nbytes);
>extern int wait_for_random_bytes(void);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) rand_initialize(void);
>extern bool rng_is_initialized(void);
>extern int add_random_ready_callback(struct random_ready_callback *rdy);
>extern void del_random_ready_callback(struct random_ready_callback *rdy);
>extern int __attribute__((__warn_unused_result__)) get_random_bytes_arch(void *buf, int nbytes);
>
>
>
>
>
>u32 get_random_u32(void);
>u64 get_random_u64(void);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int get_random_int(void)
>{
> return get_random_u32();
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_random_long(void)
>{
>
> return get_random_u64();
>
>
>
>}
># 77 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_random_canary(void)
>{
> unsigned long val = get_random_long();
>
> return val & 0xffffffffffffff00UL;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_random_bytes_wait(void *buf, int nbytes)
>{
> int ret = wait_for_random_bytes();
> get_random_bytes(buf, nbytes);
> return ret;
>}
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_random_u32_wait(u32 *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_u32(); return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_random_u64_wait(u64 *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_u64(); return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_random_int_wait(int *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_int(); return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_random_long_wait(long *out) { int ret = wait_for_random_bytes(); if (__builtin_expect(!!(ret), 0)) return ret; *out = get_random_long(); return 0; }
>
>
>unsigned long randomize_page(unsigned long start, unsigned long range);
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/prandom.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/prandom.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu.h" 1
># 64 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu.h"
>extern void *pcpu_base_addr;
>extern const unsigned long *pcpu_unit_offsets;
>
>struct pcpu_group_info {
> int nr_units;
> unsigned long 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[];
>};
>
>enum pcpu_fc {
> PCPU_FC_AUTO,
> PCPU_FC_EMBED,
> PCPU_FC_PAGE,
>
> PCPU_FC_NR,
>};
>extern const char * const pcpu_fc_names[PCPU_FC_NR];
>
>extern enum pcpu_fc pcpu_chosen_fc;
>
>typedef void * (*pcpu_fc_alloc_fn_t)(unsigned int cpu, size_t size,
>         size_t align);
>typedef void (*pcpu_fc_free_fn_t)(void *ptr, size_t size);
>typedef void (*pcpu_fc_populate_pte_fn_t)(unsigned long addr);
>typedef int (pcpu_fc_cpu_distance_fn_t)(unsigned int from, unsigned int to);
>
>extern struct pcpu_alloc_info * __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pcpu_alloc_alloc_info(int nr_groups,
>            int nr_units);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pcpu_free_alloc_info(struct pcpu_alloc_info *ai);
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pcpu_setup_first_chunk(const struct pcpu_alloc_info *ai,
>      void *base_addr);
>
>
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pcpu_embed_first_chunk(size_t reserved_size, size_t dyn_size,
>    size_t atom_size,
>    pcpu_fc_cpu_distance_fn_t cpu_distance_fn,
>    pcpu_fc_alloc_fn_t alloc_fn,
>    pcpu_fc_free_fn_t free_fn);
>
>
>
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pcpu_page_first_chunk(size_t reserved_size,
>    pcpu_fc_alloc_fn_t alloc_fn,
>    pcpu_fc_free_fn_t free_fn,
>    pcpu_fc_populate_pte_fn_t populate_pte_fn);
>
>
>extern void *__alloc_reserved_percpu(size_t size, size_t align);
>extern bool __is_kernel_percpu_address(unsigned long addr, unsigned long *can_addr);
>extern bool is_kernel_percpu_address(unsigned long addr);
>
>
>
>
>
>extern void *__alloc_percpu_gfp(size_t size, size_t align, gfp_t gfp);
>extern void *__alloc_percpu(size_t size, size_t align);
>extern void free_percpu(void *__pdata);
>extern phys_addr_t per_cpu_ptr_to_phys(void *addr);
># 145 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu.h"
>extern unsigned long pcpu_nr_pages(void);
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/prandom.h" 2
>
>u32 prandom_u32(void);
>void prandom_bytes(void *buf, size_t nbytes);
>void prandom_seed(u32 seed);
>void prandom_reseed_late(void);
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_net_rand_noise; extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) net_rand_noise;
># 59 "/usr/src/linux-5.14.21-150500.53/include/linux/prandom.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void prandom_u32_add_noise(unsigned long a, unsigned long b,
>      unsigned long c, unsigned long d)
>{
>
>
>
>
> a ^= ({ typeof(net_rand_noise) pscr_ret__; do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(net_rand_noise)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (net_rand_noise)); (typeof(net_rand_noise))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (net_rand_noise)); (typeof(net_rand_noise))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (net_rand_noise)); (typeof(net_rand_noise))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (net_rand_noise)); (typeof(net_rand_noise))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; });
> ( a += b, b = rol64(b, 13), c += d, d = rol64(d, 16), b ^= a, a = rol64(a, 32), d ^= c, a += d, d = rol64(d, 21), c += b, b = rol64(b, 17), d ^= a, b ^= c, c = rol64(c, 32) );
> do { do { const void *__vpp_verify = (typeof((&(net_rand_noise)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(net_rand_noise)) { case 1: do { u8 pto_val__ = ((u8)(((unsigned long) d) & 0xff)); if (0) { typeof((net_rand_noise)) pto_tmp__; pto_tmp__ = (d); (void)pto_tmp__; } asm ("mov" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((net_rand_noise)) : [val] "qi" (pto_val__)); } while (0);break; case 2: do { u16 pto_val__ = ((u16)(((unsigned long) d) & 0xffff)); if (0) { typeof((net_rand_noise)) pto_tmp__; pto_tmp__ = (d); (void)pto_tmp__; } asm ("mov" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((net_rand_noise)) : [val] "ri" (pto_val__)); } while (0);break; case 4: do { u32 pto_val__ = ((u32)(((unsigned long) d) & 0xffffffff)); if (0) { typeof((net_rand_noise)) pto_tmp__; pto_tmp__ = (d); (void)pto_tmp__; } asm ("mov" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((net_rand_noise)) : [val] "ri" (pto_val__)); } while (0);break; case 8: do { u64 pto_val__ = ((u64)(d)); if (0) { typeof((net_rand_noise)) pto_tmp__; pto_tmp__ = (d); (void)pto_tmp__; } asm ("mov" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((net_rand_noise)) : [val] "re" (pto_val__)); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>struct rnd_state {
> __u32 s1, s2, s3, s4;
>};
>
>u32 prandom_u32_state(struct rnd_state *state);
>void prandom_bytes_state(struct rnd_state *state, void *buf, size_t nbytes);
>void prandom_seed_full_state(struct rnd_state *pcpu_state);
># 94 "/usr/src/linux-5.14.21-150500.53/include/linux/prandom.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 prandom_u32_max(u32 ep_ro)
>{
> return (u32)(((u64) prandom_u32() * ep_ro) >> 32);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 __seed(u32 x, u32 m)
>{
> return (x < m) ? x + m : x;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void prandom_seed_state(struct rnd_state *state, u64 seed)
>{
> u32 i = ((seed >> 32) ^ (seed << 10) ^ seed) & 0xffffffffUL;
>
> state->s1 = __seed(i, 2U);
> state->s2 = __seed(i, 8U);
> state->s3 = __seed(i, 16U);
> state->s4 = __seed(i, 128U);
> prandom_u32_add_noise((unsigned long)(state), (unsigned long)(i), (unsigned long)(0), (unsigned long)(0));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 next_pseudo_random32(u32 seed)
>{
> return seed * 1664525 + 1013904223;
>}
># 115 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/archrandom.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/archrandom.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) rdrand_long(unsigned long *v)
>{
> bool ok;
> unsigned int retry = 10;
> do {
>  asm volatile("rdrand %[out]"
>        "\n\t/* output condition code " "c" "*/\n"
>        : "=@cc" "c" (ok), [out] "=r" (*v));
>  if (ok)
>   return true;
> } while (--retry);
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) rdrand_int(unsigned int *v)
>{
> bool ok;
> unsigned int retry = 10;
> do {
>  asm volatile("rdrand %[out]"
>        "\n\t/* output condition code " "c" "*/\n"
>        : "=@cc" "c" (ok), [out] "=r" (*v));
>  if (ok)
>   return true;
> } while (--retry);
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) rdseed_long(unsigned long *v)
>{
> bool ok;
> asm volatile("rdseed %[out]"
>       "\n\t/* output condition code " "c" "*/\n"
>       : "=@cc" "c" (ok), [out] "=r" (*v));
> return ok;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) rdseed_int(unsigned int *v)
>{
> bool ok;
> asm volatile("rdseed %[out]"
>       "\n\t/* output condition code " "c" "*/\n"
>       : "=@cc" "c" (ok), [out] "=r" (*v));
> return ok;
>}
># 73 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/archrandom.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) arch_get_random_long(unsigned long *v)
>{
> return ( __builtin_constant_p((__builtin_constant_p(( 4*32+30)) && ( (((( 4*32+30))>>5)==(0) && (1UL<<((( 4*32+30))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 4*32+30))>>5)==(1) && (1UL<<((( 4*32+30))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 4*32+30))>>5)==(2) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(3) && (1UL<<((( 4*32+30))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 4*32+30))>>5)==(4) && (1UL<<((( 4*32+30))&31) & (0) )) || (((( 4*32+30))>>5)==(5) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(6) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(7) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(8) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(9) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(10) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(11) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(12) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(13) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(14) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(15) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(16) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(17) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(18) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(19) && (1UL<<((( 4*32+30))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 4*32+30), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p(( 4*32+30)) && ( (((( 4*32+30))>>5)==(0) && (1UL<<((( 4*32+30))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 4*32+30))>>5)==(1) && (1UL<<((( 4*32+30))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 4*32+30))>>5)==(2) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(3) && (1UL<<((( 4*32+30))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 4*32+30))>>5)==(4) && (1UL<<((( 4*32+30))&31) & (0) )) || (((( 4*32+30))>>5)==(5) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(6) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(7) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(8) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(9) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(10) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(11) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(12) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(13) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(14) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(15) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(16) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(17) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(18) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(19) && (1UL<<((( 4*32+30))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 4*32+30), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has(( 4*32+30)) ) ? rdrand_long(v) : false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) arch_get_random_int(unsigned int *v)
>{
> return ( __builtin_constant_p((__builtin_constant_p(( 4*32+30)) && ( (((( 4*32+30))>>5)==(0) && (1UL<<((( 4*32+30))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 4*32+30))>>5)==(1) && (1UL<<((( 4*32+30))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 4*32+30))>>5)==(2) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(3) && (1UL<<((( 4*32+30))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 4*32+30))>>5)==(4) && (1UL<<((( 4*32+30))&31) & (0) )) || (((( 4*32+30))>>5)==(5) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(6) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(7) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(8) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(9) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(10) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(11) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(12) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(13) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(14) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(15) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(16) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(17) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(18) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(19) && (1UL<<((( 4*32+30))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 4*32+30), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p(( 4*32+30)) && ( (((( 4*32+30))>>5)==(0) && (1UL<<((( 4*32+30))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 4*32+30))>>5)==(1) && (1UL<<((( 4*32+30))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 4*32+30))>>5)==(2) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(3) && (1UL<<((( 4*32+30))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 4*32+30))>>5)==(4) && (1UL<<((( 4*32+30))&31) & (0) )) || (((( 4*32+30))>>5)==(5) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(6) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(7) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(8) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(9) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(10) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(11) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(12) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(13) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(14) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(15) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(16) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(17) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(18) && (1UL<<((( 4*32+30))&31) & 0 )) || (((( 4*32+30))>>5)==(19) && (1UL<<((( 4*32+30))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 4*32+30), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has(( 4*32+30)) ) ? rdrand_int(v) : false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) arch_get_random_seed_long(unsigned long *v)
>{
> return ( __builtin_constant_p((__builtin_constant_p(( 9*32+18)) && ( (((( 9*32+18))>>5)==(0) && (1UL<<((( 9*32+18))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 9*32+18))>>5)==(1) && (1UL<<((( 9*32+18))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 9*32+18))>>5)==(2) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(3) && (1UL<<((( 9*32+18))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 9*32+18))>>5)==(4) && (1UL<<((( 9*32+18))&31) & (0) )) || (((( 9*32+18))>>5)==(5) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(6) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(7) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(8) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(9) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(10) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(11) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(12) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(13) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(14) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(15) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(16) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(17) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(18) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(19) && (1UL<<((( 9*32+18))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 9*32+18), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p(( 9*32+18)) && ( (((( 9*32+18))>>5)==(0) && (1UL<<((( 9*32+18))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 9*32+18))>>5)==(1) && (1UL<<((( 9*32+18))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 9*32+18))>>5)==(2) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(3) && (1UL<<((( 9*32+18))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 9*32+18))>>5)==(4) && (1UL<<((( 9*32+18))&31) & (0) )) || (((( 9*32+18))>>5)==(5) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(6) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(7) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(8) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(9) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(10) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(11) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(12) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(13) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(14) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(15) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(16) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(17) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(18) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(19) && (1UL<<((( 9*32+18))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 9*32+18), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has(( 9*32+18)) ) ? rdseed_long(v) : false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) arch_get_random_seed_int(unsigned int *v)
>{
> return ( __builtin_constant_p((__builtin_constant_p(( 9*32+18)) && ( (((( 9*32+18))>>5)==(0) && (1UL<<((( 9*32+18))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 9*32+18))>>5)==(1) && (1UL<<((( 9*32+18))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 9*32+18))>>5)==(2) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(3) && (1UL<<((( 9*32+18))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 9*32+18))>>5)==(4) && (1UL<<((( 9*32+18))&31) & (0) )) || (((( 9*32+18))>>5)==(5) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(6) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(7) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(8) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(9) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(10) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(11) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(12) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(13) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(14) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(15) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(16) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(17) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(18) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(19) && (1UL<<((( 9*32+18))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 9*32+18), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p(( 9*32+18)) && ( (((( 9*32+18))>>5)==(0) && (1UL<<((( 9*32+18))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 9*32+18))>>5)==(1) && (1UL<<((( 9*32+18))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 9*32+18))>>5)==(2) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(3) && (1UL<<((( 9*32+18))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 9*32+18))>>5)==(4) && (1UL<<((( 9*32+18))&31) & (0) )) || (((( 9*32+18))>>5)==(5) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(6) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(7) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(8) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(9) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(10) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(11) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(12) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(13) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(14) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(15) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(16) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(17) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(18) && (1UL<<((( 9*32+18))&31) & 0 )) || (((( 9*32+18))>>5)==(19) && (1UL<<((( 9*32+18))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 9*32+18), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has(( 9*32+18)) ) ? rdseed_int(v) : false;
>}
>
>extern void x86_init_rdrand(struct cpuinfo_x86 *c);
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h" 2
># 142 "/usr/src/linux-5.14.21-150500.53/include/linux/random.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__section__(".init.text"))) __attribute__((__cold__)) arch_get_random_seed_long_early(unsigned long *v)
>{
> ({ int __ret_warn_on = !!(system_state != SYSTEM_BOOTING); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/random.h"), "i" (144), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("83" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "83" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return arch_get_random_seed_long(v);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__section__(".init.text"))) __attribute__((__cold__)) arch_get_random_long_early(unsigned long *v)
>{
> ({ int __ret_warn_on = !!(system_state != SYSTEM_BOOTING); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/random.h"), "i" (152), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("84" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "84" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return arch_get_random_long(v);
>}
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h" 2
>
>typedef struct { unsigned long bits[((((1 << 10)) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))]; } nodemask_t;
>extern nodemask_t _unused_nodemask_arg_;
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __nodemask_pr_numnodes(const nodemask_t *m)
>{
> return m ? (1 << 10) : 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const unsigned long *__nodemask_pr_bits(const nodemask_t *m)
>{
> return m ? m->bits : ((void *)0);
>}
># 129 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __node_set(int node, volatile nodemask_t *dstp)
>{
> set_bit(node, dstp->bits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __node_clear(int node, volatile nodemask_t *dstp)
>{
> clear_bit(node, dstp->bits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_setall(nodemask_t *dstp, unsigned int nbits)
>{
> bitmap_fill(dstp->bits, nbits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_clear(nodemask_t *dstp, unsigned int nbits)
>{
> bitmap_zero(dstp->bits, nbits);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __node_test_and_set(int node, nodemask_t *addr)
>{
> return test_and_set_bit(node, addr->bits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_and(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> bitmap_and(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_or(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> bitmap_or(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_xor(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> bitmap_xor(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_andnot(nodemask_t *dstp, const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> bitmap_andnot(dstp->bits, src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_complement(nodemask_t *dstp,
>     const nodemask_t *srcp, unsigned int nbits)
>{
> bitmap_complement(dstp->bits, srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __nodes_equal(const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> return bitmap_equal(src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __nodes_intersects(const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> return bitmap_intersects(src1p->bits, src2p->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __nodes_subset(const nodemask_t *src1p,
>     const nodemask_t *src2p, unsigned int nbits)
>{
> return bitmap_subset(src1p->bits, src2p->bits, nbits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __nodes_empty(const nodemask_t *srcp, unsigned int nbits)
>{
> return bitmap_empty(srcp->bits, nbits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __nodes_full(const nodemask_t *srcp, unsigned int nbits)
>{
> return bitmap_full(srcp->bits, nbits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __nodes_weight(const nodemask_t *srcp, unsigned int nbits)
>{
> return bitmap_weight(srcp->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_shift_right(nodemask_t *dstp,
>     const nodemask_t *srcp, int n, int nbits)
>{
> bitmap_shift_right(dstp->bits, srcp->bits, n, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_shift_left(nodemask_t *dstp,
>     const nodemask_t *srcp, int n, int nbits)
>{
> bitmap_shift_left(dstp->bits, srcp->bits, n, nbits);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __first_node(const nodemask_t *srcp)
>{
> return __builtin_choose_expr(((!!(sizeof((typeof((unsigned int)((1 << 10))) *)1 == (typeof((unsigned int)(find_first_bit(srcp->bits, (1 << 10)))) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)((1 << 10))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)(find_first_bit(srcp->bits, (1 << 10)))) * 0l)) : (int *)8))))), (((unsigned int)((1 << 10))) < ((unsigned int)(find_first_bit(srcp->bits, (1 << 10)))) ? ((unsigned int)((1 << 10))) : ((unsigned int)(find_first_bit(srcp->bits, (1 << 10))))), ({ typeof((unsigned int)((1 << 10))) __UNIQUE_ID___x85 = ((unsigned int)((1 << 10))); typeof((unsigned int)(find_first_bit(srcp->bits, (1 << 10)))) __UNIQUE_ID___y86 = ((unsigned int)(find_first_bit(srcp->bits, (1 << 10)))); ((__UNIQUE_ID___x85) < (__UNIQUE_ID___y86) ? (__UNIQUE_ID___x85) : (__UNIQUE_ID___y86)); }));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __next_node(int n, const nodemask_t *srcp)
>{
> return __builtin_choose_expr(((!!(sizeof((typeof((unsigned int)((1 << 10))) *)1 == (typeof((unsigned int)(find_next_bit(srcp->bits, (1 << 10), n+1))) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)((1 << 10))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)(find_next_bit(srcp->bits, (1 << 10), n+1))) * 0l)) : (int *)8))))), (((unsigned int)((1 << 10))) < ((unsigned int)(find_next_bit(srcp->bits, (1 << 10), n+1))) ? ((unsigned int)((1 << 10))) : ((unsigned int)(find_next_bit(srcp->bits, (1 << 10), n+1)))), ({ typeof((unsigned int)((1 << 10))) __UNIQUE_ID___x87 = ((unsigned int)((1 << 10))); typeof((unsigned int)(find_next_bit(srcp->bits, (1 << 10), n+1))) __UNIQUE_ID___y88 = ((unsigned int)(find_next_bit(srcp->bits, (1 << 10), n+1))); ((__UNIQUE_ID___x87) < (__UNIQUE_ID___y88) ? (__UNIQUE_ID___x87) : (__UNIQUE_ID___y88)); }));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __next_node_in(int node, const nodemask_t *srcp)
>{
> unsigned int ret = __next_node(node, srcp);
>
> if (ret == (1 << 10))
>  ret = __first_node(srcp);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_nodemask_of_node(nodemask_t *mask, int node)
>{
> __nodes_clear(&(*mask), (1 << 10));
> __node_set((node), &(*mask));
>}
># 307 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __first_unset_node(const nodemask_t *maskp)
>{
> return __builtin_choose_expr(((!!(sizeof((typeof((unsigned int)((1 << 10))) *)1 == (typeof((unsigned int)(find_first_zero_bit(maskp->bits, (1 << 10)))) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)((1 << 10))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)(find_first_zero_bit(maskp->bits, (1 << 10)))) * 0l)) : (int *)8))))), (((unsigned int)((1 << 10))) < ((unsigned int)(find_first_zero_bit(maskp->bits, (1 << 10)))) ? ((unsigned int)((1 << 10))) : ((unsigned int)(find_first_zero_bit(maskp->bits, (1 << 10))))), ({ typeof((unsigned int)((1 << 10))) __UNIQUE_ID___x89 = ((unsigned int)((1 << 10))); typeof((unsigned int)(find_first_zero_bit(maskp->bits, (1 << 10)))) __UNIQUE_ID___y90 = ((unsigned int)(find_first_zero_bit(maskp->bits, (1 << 10)))); ((__UNIQUE_ID___x89) < (__UNIQUE_ID___y90) ? (__UNIQUE_ID___x89) : (__UNIQUE_ID___y90)); }))
>                                                  ;
>}
># 341 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __nodemask_parse_user(const char *buf, int len,
>     nodemask_t *dstp, int nbits)
>{
> return bitmap_parse_user(buf, len, dstp->bits, nbits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __nodelist_parse(const char *buf, nodemask_t *dstp, int nbits)
>{
> return bitmap_parselist(buf, dstp->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __node_remap(int oldbit,
>  const nodemask_t *oldp, const nodemask_t *newp, int nbits)
>{
> return bitmap_bitremap(oldbit, oldp->bits, newp->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_remap(nodemask_t *dstp, const nodemask_t *srcp,
>  const nodemask_t *oldp, const nodemask_t *newp, int nbits)
>{
> bitmap_remap(dstp->bits, srcp->bits, oldp->bits, newp->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_onto(nodemask_t *dstp, const nodemask_t *origp,
>  const nodemask_t *relmapp, int nbits)
>{
> bitmap_onto(dstp->bits, origp->bits, relmapp->bits, nbits);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __nodes_fold(nodemask_t *dstp, const nodemask_t *origp,
>  int sz, int nbits)
>{
> bitmap_fold(dstp->bits, origp->bits, sz, nbits);
>}
># 399 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>enum node_states {
> N_POSSIBLE,
> N_ONLINE,
> N_NORMAL_MEMORY,
>
>
>
> N_HIGH_MEMORY = N_NORMAL_MEMORY,
>
> N_MEMORY,
> N_CPU,
> N_GENERIC_INITIATOR,
> NR_NODE_STATES
>};
>
>
>
>
>
>
>extern nodemask_t node_states[NR_NODE_STATES];
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int node_state(int node, enum node_states state)
>{
> return test_bit((node), (node_states[state]).bits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void node_set_state(int node, enum node_states state)
>{
> __node_set(node, &node_states[state]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void node_clear_state(int node, enum node_states state)
>{
> __node_clear(node, &node_states[state]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int num_node_state(enum node_states state)
>{
> return __nodes_weight(&(node_states[state]), (1 << 10));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int next_online_node(int nid)
>{
> return __next_node((nid), &(node_states[N_ONLINE]));
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int next_memory_node(int nid)
>{
> return __next_node((nid), &(node_states[N_MEMORY]));
>}
>
>extern unsigned int nr_node_ids;
>extern unsigned int nr_online_nodes;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void node_set_online(int nid)
>{
> node_set_state(nid, N_ONLINE);
> nr_online_nodes = num_node_state(N_ONLINE);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void node_set_offline(int nid)
>{
> node_clear_state(nid, N_ONLINE);
> nr_online_nodes = num_node_state(N_ONLINE);
>}
># 505 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int node_random(const nodemask_t *maskp)
>{
>
> int w, bit;
>
> w = __nodes_weight(&(*maskp), (1 << 10));
> switch (w) {
> case 0:
>  bit = (-1);
>  break;
> case 1:
>  bit = __first_node(&(*maskp));
>  break;
> default:
>  bit = bitmap_ord_to_pos(maskp->bits,
>     get_random_int() % w, (1 << 10));
>  break;
> }
> return bit;
>
>
>
>}
># 555 "/usr/src/linux-5.14.21-150500.53/include/linux/nodemask.h"
>struct nodemask_scratch {
> nodemask_t mask1;
> nodemask_t mask2;
>};
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pageblock-flags.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/pageblock-flags.h"
>enum pageblock_bits {
> PB_migrate,
> PB_migrate_end = PB_migrate + 3 - 1,
>
> PB_migrate_skip,
>
>
>
>
>
> NR_PAGEBLOCK_BITS
>};
># 55 "/usr/src/linux-5.14.21-150500.53/include/linux/pageblock-flags.h"
>struct page;
>
>unsigned long get_pfnblock_flags_mask(const struct page *page,
>    unsigned long pfn,
>    unsigned long mask);
>
>void set_pfnblock_flags_mask(struct page *page,
>    unsigned long flags,
>    unsigned long pfn,
>    unsigned long mask);
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags-layout.h" 1
>
>
>
>
>
># 1 "./include/generated/bounds.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags-layout.h" 2
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types_task.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types_task.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tlbbatch.h" 1
>
>
>
>
>
>
>struct arch_tlbflush_unmap_batch {
>
>
>
>
> struct cpumask cpumask;
>};
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types_task.h" 2
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types_task.h"
>struct vmacache {
> u64 seqnum;
> struct vm_area_struct *vmas[(1U << 2)];
>};
>
>
>
>
>
>enum {
> MM_FILEPAGES,
> MM_ANONPAGES,
> MM_SWAPENTS,
> MM_SHMEMPAGES,
> NR_MM_COUNTERS
>};
>
>
>
>
>struct task_rss_stat {
> int events;
> int count[NR_MM_COUNTERS];
>};
>
>
>struct mm_rss_stat {
> atomic_long_t count[NR_MM_COUNTERS];
>};
>
>struct page_frag {
> struct page *page;
>
> __u32 offset;
> __u32 size;
>
>
>
>
>};
>
>
>struct tlbflush_unmap_batch {
># 85 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types_task.h"
> struct arch_tlbflush_unmap_batch arch;
>
>
> bool flush_required;
>
>
>
>
>
>
> bool writable;
>
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/auxvec.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/auxvec.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/auxvec.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/auxvec.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/auxvec.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>void call_rcu(struct callback_head *head, rcu_callback_t func);
>void rcu_barrier_tasks(void);
>void rcu_barrier_tasks_rude(void);
>void synchronize_rcu(void);
>
>
>
>void __rcu_read_lock(void);
>void __rcu_read_unlock(void);
># 85 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>void rcu_init(void);
>extern int rcu_scheduler_active __attribute__((__section__(".data..read_mostly")));
>void rcu_sched_clock_irq(int user);
>void rcu_report_dead(unsigned int cpu);
>void rcutree_migrate_callbacks(int cpu);
>
>
>void rcu_init_tasks_generic(void);
>
>
>
>
>
>void rcu_sysrq_start(void);
>void rcu_sysrq_end(void);
>
>
>
>
>
>
>void rcu_user_enter(void);
>void rcu_user_exit(void);
>
>
>
>
>
>
>void rcu_init_nohz(void);
>int rcu_nocb_cpu_offload(int cpu);
>int rcu_nocb_cpu_deoffload(int cpu);
>void rcu_nocb_flush_deferred_wakeup(void);
># 162 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>void call_rcu_tasks(struct callback_head *head, rcu_callback_t func);
>void synchronize_rcu_tasks(void);
># 190 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>void call_rcu_tasks_rude(struct callback_head *head, rcu_callback_t func);
>void synchronize_rcu_tasks_rude(void);
>
>
>
>void exit_tasks_rcu_start(void);
>void exit_tasks_rcu_finish(void);
># 225 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rcutree.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/rcutree.h"
>void rcu_softirq_qs(void);
>void rcu_note_context_switch(bool preempt);
>int rcu_needs_cpu(u64 basem, u64 *nextevt);
>void rcu_cpu_stall_reset(void);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_virt_note_context_switch(int cpu)
>{
> rcu_note_context_switch(false);
>}
>
>void synchronize_rcu_expedited(void);
>void kvfree_call_rcu(struct callback_head *head, rcu_callback_t func);
>
>void rcu_barrier(void);
>bool rcu_eqs_special_set(int cpu);
>void rcu_momentary_dyntick_idle(void);
>void kfree_rcu_scheduler_running(void);
>bool rcu_gp_might_be_stalled(void);
>unsigned long get_state_synchronize_rcu(void);
>unsigned long start_poll_synchronize_rcu(void);
>bool poll_state_synchronize_rcu(unsigned long oldstate);
>void cond_synchronize_rcu(unsigned long oldstate);
>
>void rcu_idle_enter(void);
>void rcu_idle_exit(void);
>void rcu_irq_enter(void);
>void rcu_irq_exit(void);
>void rcu_irq_enter_irqson(void);
>void rcu_irq_exit_irqson(void);
>bool rcu_is_idle_cpu(int cpu);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_irq_exit_check_preempt(void) { }
>
>
>void exit_rcu(void);
>
>void rcu_scheduler_starting(void);
>extern int rcu_scheduler_active __attribute__((__section__(".data..read_mostly")));
>void rcu_end_inkernel_boot(void);
>bool rcu_inkernel_boot_has_ended(void);
>bool rcu_is_watching(void);
>
>
>
>
>
>int rcutree_prepare_cpu(unsigned int cpu);
>int rcutree_online_cpu(unsigned int cpu);
>int rcutree_offline_cpu(unsigned int cpu);
>int rcutree_dead_cpu(unsigned int cpu);
>int rcutree_dying_cpu(unsigned int cpu);
>void rcu_cpu_starting(unsigned int cpu);
># 226 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h" 2
># 246 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_rcu_head(struct callback_head *head) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_rcu_head(struct callback_head *head) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_rcu_head_on_stack(struct callback_head *head) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_rcu_head_on_stack(struct callback_head *head) { }
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool rcu_lockdep_current_cpu_online(void) { return true; }
>
>
>extern struct lockdep_map rcu_lock_map;
>extern struct lockdep_map rcu_bh_lock_map;
>extern struct lockdep_map rcu_sched_lock_map;
>extern struct lockdep_map rcu_callback_map;
># 286 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rcu_read_lock_held(void)
>{
> return 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rcu_read_lock_bh_held(void)
>{
> return 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rcu_read_lock_sched_held(void)
>{
> return !(preempt_count() == 0 && !({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); }));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rcu_read_lock_any_held(void)
>{
> return !(preempt_count() == 0 && !({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); }));
>}
># 683 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void rcu_read_lock(void)
>{
> __rcu_read_lock();
> (void)0;
> do { } while (0);
> do { } while (0 && (!rcu_is_watching()))
>                                                ;
>}
># 714 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_read_unlock(void)
>{
> do { } while (0 && (!rcu_is_watching()))
>                                                  ;
> (void)0;
> __rcu_read_unlock();
> do { } while (0);
>}
># 737 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_read_lock_bh(void)
>{
> local_bh_disable();
> (void)0;
> do { } while (0);
> do { } while (0 && (!rcu_is_watching()))
>                                                   ;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_read_unlock_bh(void)
>{
> do { } while (0 && (!rcu_is_watching()))
>                                                     ;
> do { } while (0);
> (void)0;
> local_bh_enable();
>}
># 775 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_read_lock_sched(void)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> (void)0;
> do { } while (0);
> do { } while (0 && (!rcu_is_watching()))
>                                                      ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void rcu_read_lock_sched_notrace(void)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> (void)0;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_read_unlock_sched(void)
>{
> do { } while (0 && (!rcu_is_watching()))
>                                                        ;
> do { } while (0);
> (void)0;
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void rcu_read_unlock_sched_notrace(void)
>{
> (void)0;
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule_notrace" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
># 975 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcu_head_init(struct callback_head *rhp)
>{
> rhp->func = (rcu_callback_t)~0L;
>}
># 993 "/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>rcu_head_after_call_rcu(struct callback_head *rhp, rcu_callback_t f)
>{
> rcu_callback_t func = ({ do { extern void __compiletime_assert_91(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(rhp->func) == sizeof(char) || sizeof(rhp->func) == sizeof(short) || sizeof(rhp->func) == sizeof(int) || sizeof(rhp->func) == sizeof(long)) || sizeof(rhp->func) == sizeof(long long))) __compiletime_assert_91(); } while (0); (*(const volatile typeof( _Generic((rhp->func), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (rhp->func))) *)&(rhp->func)); });
>
> if (func == f)
>  return true;
> ({ int __ret_warn_on = !!(func != (rcu_callback_t)~0L); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/rcupdate.h"), "i" (1000), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("92" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "92" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return false;
>}
>
>
>extern int rcu_expedited;
>extern int rcu_normal;
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h" 2
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>extern void rb_insert_color(struct rb_node *, struct rb_root *);
>extern void rb_erase(struct rb_node *, struct rb_root *);
>
>
>
>extern struct rb_node *rb_next(const struct rb_node *);
>extern struct rb_node *rb_prev(const struct rb_node *);
>extern struct rb_node *rb_first(const struct rb_root *);
>extern struct rb_node *rb_last(const struct rb_root *);
>
>
>extern struct rb_node *rb_first_postorder(const struct rb_root *);
>extern struct rb_node *rb_next_postorder(const struct rb_node *);
>
>
>extern void rb_replace_node(struct rb_node *victim, struct rb_node *new,
>       struct rb_root *root);
>extern void rb_replace_node_rcu(struct rb_node *victim, struct rb_node *new,
>    struct rb_root *root);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rb_link_node(struct rb_node *node, struct rb_node *parent,
>    struct rb_node **rb_link)
>{
> node->__rb_parent_color = (unsigned long)parent;
> node->rb_left = node->rb_right = ((void *)0);
>
> *rb_link = node;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rb_link_node_rcu(struct rb_node *node, struct rb_node *parent,
>        struct rb_node **rb_link)
>{
> node->__rb_parent_color = (unsigned long)parent;
> node->rb_left = node->rb_right = ((void *)0);
>
> do { uintptr_t _r_a_p__v = (uintptr_t)(node); ; if (__builtin_constant_p(node) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_93(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((*rb_link)) == sizeof(char) || sizeof((*rb_link)) == sizeof(short) || sizeof((*rb_link)) == sizeof(int) || sizeof((*rb_link)) == sizeof(long)) || sizeof((*rb_link)) == sizeof(long long))) __compiletime_assert_93(); } while (0); do { *(volatile typeof((*rb_link)) *)&((*rb_link)) = ((typeof(*rb_link))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_94(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&*rb_link) == sizeof(char) || sizeof(*&*rb_link) == sizeof(short) || sizeof(*&*rb_link) == sizeof(int) || sizeof(*&*rb_link) == sizeof(long)))) __compiletime_assert_94(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_95(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&*rb_link) == sizeof(char) || sizeof(*&*rb_link) == sizeof(short) || sizeof(*&*rb_link) == sizeof(int) || sizeof(*&*rb_link) == sizeof(long)) || sizeof(*&*rb_link) == sizeof(long long))) __compiletime_assert_95(); } while (0); do { *(volatile typeof(*&*rb_link) *)&(*&*rb_link) = ((typeof(*((typeof(*rb_link))_r_a_p__v)) *)((typeof(*rb_link))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
>}
># 108 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rb_insert_color_cached(struct rb_node *node,
>       struct rb_root_cached *root,
>       bool leftmost)
>{
> if (leftmost)
>  root->rb_leftmost = node;
> rb_insert_color(node, &root->rb_root);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct rb_node *
>rb_erase_cached(struct rb_node *node, struct rb_root_cached *root)
>{
> struct rb_node *leftmost = ((void *)0);
>
> if (root->rb_leftmost == node)
>  leftmost = root->rb_leftmost = rb_next(node);
>
> rb_erase(node, &root->rb_root);
>
> return leftmost;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rb_replace_node_cached(struct rb_node *victim,
>       struct rb_node *new,
>       struct rb_root_cached *root)
>{
> if (root->rb_leftmost == victim)
>  root->rb_leftmost = new;
> rb_replace_node(victim, new, &root->rb_root);
>}
># 164 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct rb_node *
>rb_add_cached(struct rb_node *node, struct rb_root_cached *tree,
>       bool (*less)(struct rb_node *, const struct rb_node *))
>{
> struct rb_node **link = &tree->rb_root.rb_node;
> struct rb_node *parent = ((void *)0);
> bool leftmost = true;
>
> while (*link) {
>  parent = *link;
>  if (less(node, parent)) {
>   link = &parent->rb_left;
>  } else {
>   link = &parent->rb_right;
>   leftmost = false;
>  }
> }
>
> rb_link_node(node, parent, link);
> rb_insert_color_cached(node, tree, leftmost);
>
> return leftmost ? node : ((void *)0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>rb_add(struct rb_node *node, struct rb_root *tree,
>       bool (*less)(struct rb_node *, const struct rb_node *))
>{
> struct rb_node **link = &tree->rb_node;
> struct rb_node *parent = ((void *)0);
>
> while (*link) {
>  parent = *link;
>  if (less(node, parent))
>   link = &parent->rb_left;
>  else
>   link = &parent->rb_right;
> }
>
> rb_link_node(node, parent, link);
> rb_insert_color(node, tree);
>}
># 222 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct rb_node *
>rb_find_add(struct rb_node *node, struct rb_root *tree,
>     int (*cmp)(struct rb_node *, const struct rb_node *))
>{
> struct rb_node **link = &tree->rb_node;
> struct rb_node *parent = ((void *)0);
> int c;
>
> while (*link) {
>  parent = *link;
>  c = cmp(node, parent);
>
>  if (c < 0)
>   link = &parent->rb_left;
>  else if (c > 0)
>   link = &parent->rb_right;
>  else
>   return parent;
> }
>
> rb_link_node(node, parent, link);
> rb_insert_color(node, tree);
> return ((void *)0);
>}
># 255 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct rb_node *
>rb_find(const void *key, const struct rb_root *tree,
> int (*cmp)(const void *key, const struct rb_node *))
>{
> struct rb_node *node = tree->rb_node;
>
> while (node) {
>  int c = cmp(key, node);
>
>  if (c < 0)
>   node = node->rb_left;
>  else if (c > 0)
>   node = node->rb_right;
>  else
>   return node;
> }
>
> return ((void *)0);
>}
># 283 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct rb_node *
>rb_find_first(const void *key, const struct rb_root *tree,
>       int (*cmp)(const void *key, const struct rb_node *))
>{
> struct rb_node *node = tree->rb_node;
> struct rb_node *match = ((void *)0);
>
> while (node) {
>  int c = cmp(key, node);
>
>  if (c <= 0) {
>   if (!c)
>    match = node;
>   node = node->rb_left;
>  } else if (c > 0) {
>   node = node->rb_right;
>  }
> }
>
> return match;
>}
># 313 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct rb_node *
>rb_next_match(const void *key, struct rb_node *node,
>       int (*cmp)(const void *key, const struct rb_node *))
>{
> node = rb_next(node);
> if (node && cmp(key, node))
>  node = ((void *)0);
> return node;
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rwsem.h" 1
># 48 "/usr/src/linux-5.14.21-150500.53/include/linux/rwsem.h"
>struct rw_semaphore {
> atomic_long_t count;
>
>
>
>
>
> atomic_long_t owner;
>
> struct optimistic_spin_queue osq;
>
> raw_spinlock_t wait_lock;
> struct list_head wait_list;
>
>
>
>
>
>
>};
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rwsem_is_locked(struct rw_semaphore *sem)
>{
> return atomic_long_read(&sem->count) != 0;
>}
># 104 "/usr/src/linux-5.14.21-150500.53/include/linux/rwsem.h"
>extern void __init_rwsem(struct rw_semaphore *sem, const char *name,
>    struct lock_class_key *key);
># 120 "/usr/src/linux-5.14.21-150500.53/include/linux/rwsem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rwsem_is_contended(struct rw_semaphore *sem)
>{
> return !list_empty(&sem->wait_list);
>}
># 175 "/usr/src/linux-5.14.21-150500.53/include/linux/rwsem.h"
>extern void down_read(struct rw_semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_read_interruptible(struct rw_semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_read_killable(struct rw_semaphore *sem);
>
>
>
>
>extern int down_read_trylock(struct rw_semaphore *sem);
>
>
>
>
>extern void down_write(struct rw_semaphore *sem);
>extern int __attribute__((__warn_unused_result__)) down_write_killable(struct rw_semaphore *sem);
>
>
>
>
>extern int down_write_trylock(struct rw_semaphore *sem);
>
>
>
>
>extern void up_read(struct rw_semaphore *sem);
>
>
>
>
>extern void up_write(struct rw_semaphore *sem);
>
>
>
>
>extern void downgrade_write(struct rw_semaphore *sem);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/completion.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/completion.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/swait.h" 1
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/swait.h"
>struct task_struct;
>
>struct swait_queue_head {
> raw_spinlock_t lock;
> struct list_head task_list;
>};
>
>struct swait_queue {
> struct task_struct *task;
> struct list_head task_list;
>};
># 69 "/usr/src/linux-5.14.21-150500.53/include/linux/swait.h"
>extern void __init_swait_queue_head(struct swait_queue_head *q, const char *name,
>        struct lock_class_key *key);
># 121 "/usr/src/linux-5.14.21-150500.53/include/linux/swait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int swait_active(struct swait_queue_head *wq)
>{
> return !list_empty(&wq->task_list);
>}
># 134 "/usr/src/linux-5.14.21-150500.53/include/linux/swait.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool swq_has_sleeper(struct swait_queue_head *wq)
>{
>
>
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> return swait_active(wq);
>}
>
>extern void swake_up_one(struct swait_queue_head *q);
>extern void swake_up_all(struct swait_queue_head *q);
>extern void swake_up_locked(struct swait_queue_head *q);
>
>extern void prepare_to_swait_exclusive(struct swait_queue_head *q, struct swait_queue *wait, int state);
>extern long prepare_to_swait_event(struct swait_queue_head *q, struct swait_queue *wait, int state);
>
>extern void __finish_swait(struct swait_queue_head *q, struct swait_queue *wait);
>extern void finish_swait(struct swait_queue_head *q, struct swait_queue *wait);
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/completion.h" 2
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/completion.h"
>struct completion {
> unsigned int done;
> struct swait_queue_head wait;
>};
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void complete_acquire(struct completion *x) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void complete_release(struct completion *x) {}
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/completion.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_completion(struct completion *x)
>{
> x->done = 0;
> do { static struct lock_class_key __key; __init_swait_queue_head((&x->wait), "&x->wait", &__key); } while (0);
>}
># 97 "/usr/src/linux-5.14.21-150500.53/include/linux/completion.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void reinit_completion(struct completion *x)
>{
> x->done = 0;
>}
>
>extern void wait_for_completion(struct completion *);
>extern void wait_for_completion_io(struct completion *);
>extern int wait_for_completion_interruptible(struct completion *x);
>extern int wait_for_completion_killable(struct completion *x);
>extern unsigned long wait_for_completion_timeout(struct completion *x,
>         unsigned long timeout);
>extern unsigned long wait_for_completion_io_timeout(struct completion *x,
>          unsigned long timeout);
>extern long wait_for_completion_interruptible_timeout(
> struct completion *x, unsigned long timeout);
>extern long wait_for_completion_killable_timeout(
> struct completion *x, unsigned long timeout);
>extern bool try_wait_for_completion(struct completion *x);
>extern bool completion_done(struct completion *x);
>
>extern void complete(struct completion *);
>extern void complete_all(struct completion *);
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/uprobes.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/uprobes.h"
>struct vm_area_struct;
>struct mm_struct;
>struct inode;
>struct notifier_block;
>struct page;
>
>
>
>
>
>
>enum uprobe_filter_ctx {
> UPROBE_FILTER_REGISTER,
> UPROBE_FILTER_UNREGISTER,
> UPROBE_FILTER_MMAP,
>};
>
>struct uprobe_consumer {
> int (*handler)(struct uprobe_consumer *self, struct pt_regs *regs);
> int (*ret_handler)(struct uprobe_consumer *self,
>    unsigned long func,
>    struct pt_regs *regs);
> bool (*filter)(struct uprobe_consumer *self,
>    enum uprobe_filter_ctx ctx,
>    struct mm_struct *mm);
>
> struct uprobe_consumer *next;
>};
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uprobes.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uprobes.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/time.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/time.h"
>extern struct timezone sys_tz;
>
>int get_timespec64(struct timespec64 *ts,
>  const struct __kernel_timespec *uts);
>int put_timespec64(const struct timespec64 *ts,
>  struct __kernel_timespec *uts);
>int get_itimerspec64(struct itimerspec64 *it,
>   const struct __kernel_itimerspec *uit);
>int put_itimerspec64(const struct itimerspec64 *it,
>   struct __kernel_itimerspec *uit);
>
>extern time64_t mktime64(const unsigned int year, const unsigned int mon,
>   const unsigned int day, const unsigned int hour,
>   const unsigned int min, const unsigned int sec);
>
>
>extern void clear_itimer(void);
>
>
>
>
>extern long do_utimes(int dfd, const char *filename, struct timespec64 *times, int flags);
>
>
>
>
>
>struct tm {
>
>
>
>
> int tm_sec;
>
> int tm_min;
>
> int tm_hour;
>
> int tm_mday;
>
> int tm_mon;
>
> long tm_year;
>
> int tm_wday;
>
> int tm_yday;
>};
>
>void time64_to_tm(time64_t totalsecs, int offset, struct tm *result);
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/time32.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/time32.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h" 1
># 56 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/timex.h" 1
># 56 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/timex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/time.h" 1
># 57 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/timex.h" 2
># 97 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/timex.h"
>struct __kernel_timex_timeval {
> __kernel_time64_t tv_sec;
> long long tv_usec;
>};
>
>struct __kernel_timex {
> unsigned int modes;
> int :32;
> long long offset;
> long long freq;
> long long maxerror;
> long long esterror;
> int status;
> int :32;
> long long constant;
> long long precision;
> long long tolerance;
>
>
> struct __kernel_timex_timeval time;
> long long tick;
>
> long long ppsfreq;
> long long jitter;
> int shift;
> int :32;
> long long stabil;
> long long jitcnt;
> long long calcnt;
> long long errcnt;
> long long stbcnt;
>
> int tai;
>
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32; int :32;
> int :32; int :32; int :32;
>};
># 57 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h" 2
># 65 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/timex.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tsc.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tsc.h"
>typedef unsigned long long cycles_t;
>
>extern unsigned int cpu_khz;
>extern unsigned int tsc_khz;
>
>extern void disable_TSC(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) cycles_t get_cycles(void)
>{
>
>
>
>
>
> return rdtsc();
>}
>
>extern struct system_counterval_t convert_art_to_tsc(u64 art);
>extern struct system_counterval_t convert_art_ns_to_tsc(u64 art_ns);
>
>extern void tsc_early_init(void);
>extern void tsc_init(void);
>extern unsigned long calibrate_delay_is_known(void);
>extern void mark_tsc_unstable(char *reason);
>extern int unsynchronized_tsc(void);
>extern int check_tsc_unstable(void);
>extern void mark_tsc_async_resets(char *reason);
>extern unsigned long native_calibrate_cpu_early(void);
>extern unsigned long native_calibrate_tsc(void);
>extern unsigned long long native_sched_clock_from_tsc(u64 tsc);
>
>extern int tsc_clocksource_reliable;
>
>extern bool tsc_async_resets;
># 57 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tsc.h"
>extern bool tsc_store_and_check_tsc_adjust(bool bootcpu);
>extern void tsc_verify_tsc_adjust(bool resume);
>extern void check_tsc_sync_source(int cpu);
>extern void check_tsc_sync_target(void);
>
>
>
>
>
>
>
>extern int notsc_setup(char *);
>extern void tsc_save_sched_clock_state(void);
>extern void tsc_restore_sched_clock_state(void);
>
>unsigned long cpu_khz_from_msr(void);
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/timex.h" 2
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h" 2
># 139 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h"
>extern unsigned long tick_usec;
>extern unsigned long tick_nsec;
># 154 "/usr/src/linux-5.14.21-150500.53/include/linux/timex.h"
>extern int do_adjtimex(struct __kernel_timex *);
>extern int do_clock_adjtime(const clockid_t which_clock, struct __kernel_timex * ktx);
>
>extern void hardpps(const struct timespec64 *, const struct timespec64 *);
>
>int read_current_timer(unsigned long *timer_val);
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/time32.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/time32.h" 1
>
>
>
>
>typedef s32 old_time32_t;
>
>struct old_timespec32 {
> old_time32_t tv_sec;
> s32 tv_nsec;
>};
>
>struct old_timeval32 {
> old_time32_t tv_sec;
> s32 tv_usec;
>};
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/time32.h" 2
>
>struct old_itimerspec32 {
> struct old_timespec32 it_interval;
> struct old_timespec32 it_value;
>};
>
>struct old_utimbuf32 {
> old_time32_t actime;
> old_time32_t modtime;
>};
>
>struct old_timex32 {
> u32 modes;
> s32 offset;
> s32 freq;
> s32 maxerror;
> s32 esterror;
> s32 status;
> s32 constant;
> s32 precision;
> s32 tolerance;
> struct old_timeval32 time;
> s32 tick;
> s32 ppsfreq;
> s32 jitter;
> s32 shift;
> s32 stabil;
> s32 jitcnt;
> s32 calcnt;
> s32 errcnt;
> s32 stbcnt;
> s32 tai;
>
> s32:32; s32:32; s32:32; s32:32;
> s32:32; s32:32; s32:32; s32:32;
> s32:32; s32:32; s32:32;
>};
>
>extern int get_old_timespec32(struct timespec64 *, const void *);
>extern int put_old_timespec32(const struct timespec64 *, void *);
>extern int get_old_itimerspec32(struct itimerspec64 *its,
>   const struct old_itimerspec32 *uits);
>extern int put_old_itimerspec32(const struct itimerspec64 *its,
>   struct old_itimerspec32 *uits);
>struct __kernel_timex;
>int get_old_timex32(struct __kernel_timex *, const struct old_timex32 *);
>int put_old_timex32(struct old_timex32 *, const struct __kernel_timex *);
>
>
>
>
>
>
>
>extern struct __kernel_old_timeval ns_to_kernel_old_timeval(s64 nsec);
># 61 "/usr/src/linux-5.14.21-150500.53/include/linux/time.h" 2
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool itimerspec64_valid(const struct itimerspec64 *its)
>{
> if (!timespec64_valid(&(its->it_interval)) ||
>  !timespec64_valid(&(its->it_value)))
>  return false;
>
> return true;
>}
># 100 "/usr/src/linux-5.14.21-150500.53/include/linux/time.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/time.h" 1
>
>
>
>
>
>
>struct timens_offset {
> s64 sec;
> u64 nsec;
>};
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/time.h" 2
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/jiffies.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/param.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/vdso/jiffies.h" 2
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/param.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h" 2
># 1 "./include/generated/timeconst.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h" 2
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
>extern int register_refined_jiffies(long clock_tick_rate);
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
>extern u64 __attribute__((__aligned__((1 << (6))), __section__(".data..cacheline_aligned"))) jiffies_64;
>extern unsigned long volatile __attribute__((__aligned__((1 << (6))), __section__(".data..cacheline_aligned"))) jiffies;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 get_jiffies_64(void)
>{
> return (u64)jiffies;
>}
># 189 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
>extern unsigned long preset_lpj;
># 290 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
>extern unsigned int jiffies_to_msecs(const unsigned long j);
>extern unsigned int jiffies_to_usecs(const unsigned long j);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 jiffies_to_nsecs(const unsigned long j)
>{
> return (u64)jiffies_to_usecs(j) * 1000L;
>}
>
>extern u64 jiffies64_to_nsecs(u64 j);
>extern u64 jiffies64_to_msecs(u64 j);
>
>extern unsigned long __msecs_to_jiffies(const unsigned int m);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long _msecs_to_jiffies(const unsigned int m)
>{
> return (m + (1000L / 250) - 1) / (1000L / 250);
>}
># 363 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long msecs_to_jiffies(const unsigned int m)
>{
> if (__builtin_constant_p(m)) {
>  if ((int)m < 0)
>   return ((((long)(~0UL >> 1)) >> 1)-1);
>  return _msecs_to_jiffies(m);
> } else {
>  return __msecs_to_jiffies(m);
> }
>}
>
>extern unsigned long __usecs_to_jiffies(const unsigned int u);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long _usecs_to_jiffies(const unsigned int u)
>{
> return (u + (1000000L / 250) - 1) / (1000000L / 250);
>}
># 410 "/usr/src/linux-5.14.21-150500.53/include/linux/jiffies.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long usecs_to_jiffies(const unsigned int u)
>{
> if (__builtin_constant_p(u)) {
>  if (u > jiffies_to_usecs(((((long)(~0UL >> 1)) >> 1)-1)))
>   return ((((long)(~0UL >> 1)) >> 1)-1);
>  return _usecs_to_jiffies(u);
> } else {
>  return __usecs_to_jiffies(u);
> }
>}
>
>extern unsigned long timespec64_to_jiffies(const struct timespec64 *value);
>extern void jiffies_to_timespec64(const unsigned long jiffies,
>      struct timespec64 *value);
>extern clock_t jiffies_to_clock_t(unsigned long x);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) clock_t jiffies_delta_to_clock_t(long delta)
>{
> return jiffies_to_clock_t(__builtin_choose_expr(((!!(sizeof((typeof(0L) *)1 == (typeof(delta) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(0L) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(delta) * 0l)) : (int *)8))))), ((0L) > (delta) ? (0L) : (delta)), ({ typeof(0L) __UNIQUE_ID___x96 = (0L); typeof(delta) __UNIQUE_ID___y97 = (delta); ((__UNIQUE_ID___x96) > (__UNIQUE_ID___y97) ? (__UNIQUE_ID___x96) : (__UNIQUE_ID___y97)); })));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int jiffies_delta_to_msecs(long delta)
>{
> return jiffies_to_msecs(__builtin_choose_expr(((!!(sizeof((typeof(0L) *)1 == (typeof(delta) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(0L) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(delta) * 0l)) : (int *)8))))), ((0L) > (delta) ? (0L) : (delta)), ({ typeof(0L) __UNIQUE_ID___x98 = (0L); typeof(delta) __UNIQUE_ID___y99 = (delta); ((__UNIQUE_ID___x98) > (__UNIQUE_ID___y99) ? (__UNIQUE_ID___x98) : (__UNIQUE_ID___y99)); })));
>}
>
>extern unsigned long clock_t_to_jiffies(unsigned long x);
>extern u64 jiffies_64_to_clock_t(u64 x);
>extern u64 nsec_to_clock_t(u64 x);
>extern u64 nsecs_to_jiffies64(u64 n);
>extern unsigned long nsecs_to_jiffies(u64 n);
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h" 2
>
>
>
>typedef s64 ktime_t;
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_set(const s64 secs, const unsigned long nsecs)
>{
> if (__builtin_expect(!!(secs >= (((s64)~((u64)1 << 63)) / 1000000000L)), 0))
>  return ((s64)~((u64)1 << 63));
>
> return secs * 1000000000L + (s64)nsecs;
>}
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t timespec64_to_ktime(struct timespec64 ts)
>{
> return ktime_set(ts.tv_sec, ts.tv_nsec);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 ktime_to_ns(const ktime_t kt)
>{
> return kt;
>}
># 95 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ktime_compare(const ktime_t cmp1, const ktime_t cmp2)
>{
> if (cmp1 < cmp2)
>  return -1;
> if (cmp1 > cmp2)
>  return 1;
> return 0;
>}
># 111 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ktime_after(const ktime_t cmp1, const ktime_t cmp2)
>{
> return ktime_compare(cmp1, cmp2) > 0;
>}
># 123 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ktime_before(const ktime_t cmp1, const ktime_t cmp2)
>{
> return ktime_compare(cmp1, cmp2) < 0;
>}
># 148 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 ktime_divns(const ktime_t kt, s64 div)
>{
>
>
>
>
> ({ int __ret_warn_on = !!(div < 0); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"), "i" (154), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("100" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "100" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return kt / div;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 ktime_to_us(const ktime_t kt)
>{
> return ktime_divns(kt, 1000L);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 ktime_to_ms(const ktime_t kt)
>{
> return ktime_divns(kt, 1000000L);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 ktime_us_delta(const ktime_t later, const ktime_t earlier)
>{
>       return ktime_to_us(((later) - (earlier)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 ktime_ms_delta(const ktime_t later, const ktime_t earlier)
>{
> return ktime_to_ms(((later) - (earlier)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_add_us(const ktime_t kt, const u64 usec)
>{
> return ((kt) + (usec * 1000L));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_add_ms(const ktime_t kt, const u64 msec)
>{
> return ((kt) + (msec * 1000000L));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_sub_us(const ktime_t kt, const u64 usec)
>{
> return ((kt) - (usec * 1000L));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_sub_ms(const ktime_t kt, const u64 msec)
>{
> return ((kt) - (msec * 1000000L));
>}
>
>extern ktime_t ktime_add_safe(const ktime_t lhs, const ktime_t rhs);
># 209 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool ktime_to_timespec64_cond(const ktime_t kt,
>             struct timespec64 *ts)
>{
> if (kt) {
>  *ts = ns_to_timespec64((kt));
>  return true;
> } else {
>  return false;
> }
>}
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/vdso/ktime.h" 1
># 221 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h" 2
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ns_to_ktime(u64 ns)
>{
> return ns;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ms_to_ktime(u64 ms)
>{
> return ms * 1000000L;
>}
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/timekeeping.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/clocksource_ids.h" 1
>
>
>
>
>
>enum clocksource_ids {
> CSID_GENERIC = 0,
> CSID_ARM_ARCH_COUNTER,
> CSID_MAX,
>};
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/timekeeping.h" 2
>
>
>
>void timekeeping_init(void);
>extern int timekeeping_suspended;
>
>
>extern void legacy_timer_tick(unsigned long ticks);
>
>
>
>
>extern int do_settimeofday64(const struct timespec64 *ts);
>extern int do_sys_settimeofday64(const struct timespec64 *tv,
>     const struct timezone *tz);
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/timekeeping.h"
>extern void ktime_get_raw_ts64(struct timespec64 *ts);
>extern void ktime_get_ts64(struct timespec64 *ts);
>extern void ktime_get_real_ts64(struct timespec64 *tv);
>extern void ktime_get_coarse_ts64(struct timespec64 *ts);
>extern void ktime_get_coarse_real_ts64(struct timespec64 *ts);
>
>void getboottime64(struct timespec64 *ts);
>
>
>
>
>extern time64_t ktime_get_seconds(void);
>extern time64_t __ktime_get_real_seconds(void);
>extern time64_t ktime_get_real_seconds(void);
>
>
>
>
>
>enum tk_offsets {
> TK_OFFS_REAL,
> TK_OFFS_BOOT,
> TK_OFFS_TAI,
> TK_OFFS_MAX,
>};
>
>extern ktime_t ktime_get(void);
>extern ktime_t ktime_get_with_offset(enum tk_offsets offs);
>extern ktime_t ktime_get_coarse_with_offset(enum tk_offsets offs);
>extern ktime_t ktime_mono_to_any(ktime_t tmono, enum tk_offsets offs);
>extern ktime_t ktime_get_raw(void);
>extern u32 ktime_get_resolution_ns(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_real(void)
>{
> return ktime_get_with_offset(TK_OFFS_REAL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_coarse_real(void)
>{
> return ktime_get_coarse_with_offset(TK_OFFS_REAL);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_boottime(void)
>{
> return ktime_get_with_offset(TK_OFFS_BOOT);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_coarse_boottime(void)
>{
> return ktime_get_coarse_with_offset(TK_OFFS_BOOT);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_clocktai(void)
>{
> return ktime_get_with_offset(TK_OFFS_TAI);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_coarse_clocktai(void)
>{
> return ktime_get_coarse_with_offset(TK_OFFS_TAI);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_get_coarse(void)
>{
> struct timespec64 ts;
>
> ktime_get_coarse_ts64(&ts);
> return timespec64_to_ktime(ts);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_coarse_ns(void)
>{
> return ktime_to_ns(ktime_get_coarse());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_coarse_real_ns(void)
>{
> return ktime_to_ns(ktime_get_coarse_real());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_coarse_boottime_ns(void)
>{
> return ktime_to_ns(ktime_get_coarse_boottime());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_coarse_clocktai_ns(void)
>{
> return ktime_to_ns(ktime_get_coarse_clocktai());
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t ktime_mono_to_real(ktime_t mono)
>{
> return ktime_mono_to_any(mono, TK_OFFS_REAL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_ns(void)
>{
> return ktime_to_ns(ktime_get());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_real_ns(void)
>{
> return ktime_to_ns(ktime_get_real());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_boottime_ns(void)
>{
> return ktime_to_ns(ktime_get_boottime());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_clocktai_ns(void)
>{
> return ktime_to_ns(ktime_get_clocktai());
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 ktime_get_raw_ns(void)
>{
> return ktime_to_ns(ktime_get_raw());
>}
>
>extern u64 ktime_get_mono_fast_ns(void);
>extern u64 ktime_get_raw_fast_ns(void);
>extern u64 ktime_get_boot_fast_ns(void);
>extern u64 ktime_get_real_fast_ns(void);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ktime_get_boottime_ts64(struct timespec64 *ts)
>{
> *ts = ns_to_timespec64((ktime_get_boottime()));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ktime_get_coarse_boottime_ts64(struct timespec64 *ts)
>{
> *ts = ns_to_timespec64((ktime_get_coarse_boottime()));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) time64_t ktime_get_boottime_seconds(void)
>{
> return ktime_divns(ktime_get_coarse_boottime(), 1000000000L);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ktime_get_clocktai_ts64(struct timespec64 *ts)
>{
> *ts = ns_to_timespec64((ktime_get_clocktai()));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ktime_get_coarse_clocktai_ts64(struct timespec64 *ts)
>{
> *ts = ns_to_timespec64((ktime_get_coarse_clocktai()));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) time64_t ktime_get_clocktai_seconds(void)
>{
> return ktime_divns(ktime_get_coarse_clocktai(), 1000000000L);
>}
>
>
>
>
>extern bool timekeeping_rtc_skipsuspend(void);
>extern bool timekeeping_rtc_skipresume(void);
>
>extern void timekeeping_inject_sleeptime64(const struct timespec64 *delta);
>
>
>
>
>
>
>
>struct ktime_timestamps {
> u64 mono;
> u64 boot;
> u64 real;
>};
># 246 "/usr/src/linux-5.14.21-150500.53/include/linux/timekeeping.h"
>struct system_time_snapshot {
> u64 cycles;
> ktime_t real;
> ktime_t raw;
> enum clocksource_ids cs_id;
> unsigned int clock_was_set_seq;
> u8 cs_was_changed_seq;
>};
># 262 "/usr/src/linux-5.14.21-150500.53/include/linux/timekeeping.h"
>struct system_device_crosststamp {
> ktime_t device;
> ktime_t sys_realtime;
> ktime_t sys_monoraw;
>};
># 275 "/usr/src/linux-5.14.21-150500.53/include/linux/timekeeping.h"
>struct system_counterval_t {
> u64 cycles;
> struct clocksource *cs;
>};
>
>
>
>
>extern int get_device_system_crosststamp(
>   int (*get_time_fn)(ktime_t *device_time,
>    struct system_counterval_t *system_counterval,
>    void *ctx),
>   void *ctx,
>   struct system_time_snapshot *history,
>   struct system_device_crosststamp *xtstamp);
>
>
>
>
>extern void ktime_get_snapshot(struct system_time_snapshot *systime_snapshot);
>
>
>extern void ktime_get_fast_timestamps(struct ktime_timestamps *snap);
>
>
>
>
>extern int persistent_clock_is_local;
>
>extern void read_persistent_clock64(struct timespec64 *ts);
>void read_persistent_wall_and_boot_offset(struct timespec64 *wall_clock,
>       struct timespec64 *boot_offset);
>
>extern int update_persistent_clock64(struct timespec64 now);
># 233 "/usr/src/linux-5.14.21-150500.53/include/linux/ktime.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/debugobjects.h" 1
>
>
>
>
>
>
>
>enum debug_obj_state {
> ODEBUG_STATE_NONE,
> ODEBUG_STATE_INIT,
> ODEBUG_STATE_INACTIVE,
> ODEBUG_STATE_ACTIVE,
> ODEBUG_STATE_DESTROYED,
> ODEBUG_STATE_NOTAVAILABLE,
> ODEBUG_STATE_MAX,
>};
>
>struct debug_obj_descr;
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/debugobjects.h"
>struct debug_obj {
> struct hlist_node node;
> enum debug_obj_state state;
> unsigned int astate;
> void *object;
> const struct debug_obj_descr *descr;
>};
># 55 "/usr/src/linux-5.14.21-150500.53/include/linux/debugobjects.h"
>struct debug_obj_descr {
> const char *name;
> void *(*debug_hint)(void *addr);
> bool (*is_static_object)(void *addr);
> bool (*fixup_init)(void *addr, enum debug_obj_state state);
> bool (*fixup_activate)(void *addr, enum debug_obj_state state);
> bool (*fixup_destroy)(void *addr, enum debug_obj_state state);
> bool (*fixup_free)(void *addr, enum debug_obj_state state);
> bool (*fixup_assert_init)(void *addr, enum debug_obj_state state);
>};
># 88 "/usr/src/linux-5.14.21-150500.53/include/linux/debugobjects.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_object_init (void *addr, const struct debug_obj_descr *descr) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_object_init_on_stack(void *addr, const struct debug_obj_descr *descr) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>debug_object_activate (void *addr, const struct debug_obj_descr *descr) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_object_deactivate(void *addr, const struct debug_obj_descr *descr) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_object_destroy (void *addr, const struct debug_obj_descr *descr) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_object_free (void *addr, const struct debug_obj_descr *descr) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_object_assert_init(void *addr, const struct debug_obj_descr *descr) { }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_objects_early_init(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_objects_mem_init(void) { }
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>debug_check_no_obj_freed(const void *address, unsigned long size) { }
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h" 2
>
>
>struct timer_list {
>
>
>
>
> struct hlist_node entry;
> unsigned long expires;
> void (*function)(struct timer_list *);
> u32 flags;
>
>
>
>
>};
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h"
>void init_timer_key(struct timer_list *timer,
>      void (*func)(struct timer_list *), unsigned int flags,
>      const char *name, struct lock_class_key *key);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_timer_on_stack_key(struct timer_list *timer,
>        void (*func)(struct timer_list *),
>        unsigned int flags,
>        const char *name,
>        struct lock_class_key *key)
>{
> init_timer_key(timer, func, flags, name, key);
>}
># 150 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_timer_on_stack(struct timer_list *timer) { }
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int timer_pending(const struct timer_list * timer)
>{
> return !hlist_unhashed_lockless(&timer->entry);
>}
>
>extern void add_timer_on(struct timer_list *timer, int cpu);
>extern int mod_timer(struct timer_list *timer, unsigned long expires);
>extern int mod_timer_pending(struct timer_list *timer, unsigned long expires);
>extern int timer_reduce(struct timer_list *timer, unsigned long expires);
>
>
>
>
>
>
>
>extern void add_timer(struct timer_list *timer);
>
>extern int try_to_del_timer_sync(struct timer_list *timer);
>extern int timer_delete_sync(struct timer_list *timer);
>extern int timer_delete(struct timer_list *timer);
>extern int timer_shutdown_sync(struct timer_list *timer);
>extern int timer_shutdown(struct timer_list *timer);
># 198 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int del_timer_sync(struct timer_list *timer)
>{
> return timer_delete_sync(timer);
>}
># 211 "/usr/src/linux-5.14.21-150500.53/include/linux/timer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int del_timer(struct timer_list *timer)
>{
> return timer_delete(timer);
>}
>
>extern void init_timers(void);
>struct hrtimer;
>extern enum hrtimer_restart it_real_fn(struct hrtimer *);
>
>unsigned long __round_jiffies(unsigned long j, int cpu);
>unsigned long __round_jiffies_relative(unsigned long j, int cpu);
>unsigned long round_jiffies(unsigned long j);
>unsigned long round_jiffies_relative(unsigned long j);
>
>unsigned long __round_jiffies_up(unsigned long j, int cpu);
>unsigned long __round_jiffies_up_relative(unsigned long j, int cpu);
>unsigned long round_jiffies_up(unsigned long j);
>unsigned long round_jiffies_up_relative(unsigned long j);
>
>
>int timers_prepare_cpu(unsigned int cpu);
>int timers_dead_cpu(unsigned int cpu);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h" 2
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>struct workqueue_struct;
>
>struct work_struct;
>typedef void (*work_func_t)(struct work_struct *work);
>void delayed_work_timer_fn(struct timer_list *t);
>
>
>
>
>
>
>
>enum {
> WORK_STRUCT_PENDING_BIT = 0,
> WORK_STRUCT_INACTIVE_BIT= 1,
> WORK_STRUCT_PWQ_BIT = 2,
> WORK_STRUCT_LINKED_BIT = 3,
>
>
>
>
> WORK_STRUCT_COLOR_SHIFT = 4,
>
>
> WORK_STRUCT_COLOR_BITS = 4,
>
> WORK_STRUCT_PENDING = 1 << WORK_STRUCT_PENDING_BIT,
> WORK_STRUCT_INACTIVE = 1 << WORK_STRUCT_INACTIVE_BIT,
> WORK_STRUCT_PWQ = 1 << WORK_STRUCT_PWQ_BIT,
> WORK_STRUCT_LINKED = 1 << WORK_STRUCT_LINKED_BIT,
>
>
>
> WORK_STRUCT_STATIC = 0,
>
>
> WORK_NR_COLORS = (1 << WORK_STRUCT_COLOR_BITS),
>
>
> WORK_CPU_UNBOUND = 8192,
>
>
>
>
>
>
> WORK_STRUCT_FLAG_BITS = WORK_STRUCT_COLOR_SHIFT +
>      WORK_STRUCT_COLOR_BITS,
>
>
> WORK_OFFQ_FLAG_BASE = WORK_STRUCT_COLOR_SHIFT,
>
> __WORK_OFFQ_CANCELING = WORK_OFFQ_FLAG_BASE,
> WORK_OFFQ_CANCELING = (1 << __WORK_OFFQ_CANCELING),
>
>
>
>
>
>
> WORK_OFFQ_FLAG_BITS = 1,
> WORK_OFFQ_POOL_SHIFT = WORK_OFFQ_FLAG_BASE + WORK_OFFQ_FLAG_BITS,
> WORK_OFFQ_LEFT = 64 - WORK_OFFQ_POOL_SHIFT,
> WORK_OFFQ_POOL_BITS = WORK_OFFQ_LEFT <= 31 ? WORK_OFFQ_LEFT : 31,
> WORK_OFFQ_POOL_NONE = (1LU << WORK_OFFQ_POOL_BITS) - 1,
>
>
> WORK_STRUCT_FLAG_MASK = (1UL << WORK_STRUCT_FLAG_BITS) - 1,
> WORK_STRUCT_WQ_DATA_MASK = ~WORK_STRUCT_FLAG_MASK,
> WORK_STRUCT_NO_POOL = (unsigned long)WORK_OFFQ_POOL_NONE << WORK_OFFQ_POOL_SHIFT,
>
>
> WORK_BUSY_PENDING = 1 << 0,
> WORK_BUSY_RUNNING = 1 << 1,
>
>
> WORKER_DESC_LEN = 24,
>};
>
>struct work_struct {
> atomic_long_t data;
> struct list_head entry;
> work_func_t func;
>
>
>
>};
>
>
>
>
>
>struct delayed_work {
> struct work_struct work;
> struct timer_list timer;
>
>
> struct workqueue_struct *wq;
> int cpu;
>};
>
>struct rcu_work {
> struct work_struct work;
> struct callback_head rcu;
>
>
> struct workqueue_struct *wq;
>};
>
>
>
>
>
>
>struct workqueue_attrs {
>
>
>
> int nice;
>
>
>
>
> cpumask_var_t cpumask;
># 150 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
> bool no_numa;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct delayed_work *to_delayed_work(struct work_struct *work)
>{
> return ({ void *__mptr = (void *)(work); do { extern void __compiletime_assert_101(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(work)), typeof(((struct delayed_work *)0)->work)) && !__builtin_types_compatible_p(typeof(*(work)), typeof(void))))) __compiletime_assert_101(); } while (0); ((struct delayed_work *)(__mptr - __builtin_offsetof(struct delayed_work, work))); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct rcu_work *to_rcu_work(struct work_struct *work)
>{
> return ({ void *__mptr = (void *)(work); do { extern void __compiletime_assert_102(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(work)), typeof(((struct rcu_work *)0)->work)) && !__builtin_types_compatible_p(typeof(*(work)), typeof(void))))) __compiletime_assert_102(); } while (0); ((struct rcu_work *)(__mptr - __builtin_offsetof(struct rcu_work, work))); });
>}
>
>struct execute_work {
> struct work_struct work;
>};
># 210 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __init_work(struct work_struct *work, int onstack) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_work_on_stack(struct work_struct *work) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_delayed_work_on_stack(struct delayed_work *work) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int work_static(struct work_struct *work) { return 0; }
># 303 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>enum {
> WQ_UNBOUND = 1 << 1,
> WQ_FREEZABLE = 1 << 2,
> WQ_MEM_RECLAIM = 1 << 3,
> WQ_HIGHPRI = 1 << 4,
> WQ_CPU_INTENSIVE = 1 << 5,
> WQ_SYSFS = 1 << 6,
># 336 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
> WQ_POWER_EFFICIENT = 1 << 7,
>
> __WQ_DRAINING = 1 << 16,
> __WQ_ORDERED = 1 << 17,
> __WQ_LEGACY = 1 << 18,
> __WQ_ORDERED_EXPLICIT = 1 << 19,
>
> WQ_MAX_ACTIVE = 512,
> WQ_MAX_UNBOUND_PER_CPU = 4,
> WQ_DFL_ACTIVE = WQ_MAX_ACTIVE / 2,
>};
># 380 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>extern struct workqueue_struct *system_wq;
>extern struct workqueue_struct *system_highpri_wq;
>extern struct workqueue_struct *system_long_wq;
>extern struct workqueue_struct *system_unbound_wq;
>extern struct workqueue_struct *system_freezable_wq;
>extern struct workqueue_struct *system_power_efficient_wq;
>extern struct workqueue_struct *system_freezable_power_efficient_wq;
># 402 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>struct workqueue_struct *alloc_workqueue(const char *fmt,
>      unsigned int flags,
>      int max_active, ...);
># 431 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>extern void destroy_workqueue(struct workqueue_struct *wq);
>
>struct workqueue_attrs *alloc_workqueue_attrs(void);
>void free_workqueue_attrs(struct workqueue_attrs *attrs);
>int apply_workqueue_attrs(struct workqueue_struct *wq,
>     const struct workqueue_attrs *attrs);
>int workqueue_set_unbound_cpumask(cpumask_var_t cpumask);
>
>extern bool queue_work_on(int cpu, struct workqueue_struct *wq,
>   struct work_struct *work);
>extern bool queue_work_node(int node, struct workqueue_struct *wq,
>       struct work_struct *work);
>extern bool queue_delayed_work_on(int cpu, struct workqueue_struct *wq,
>   struct delayed_work *work, unsigned long delay);
>extern bool mod_delayed_work_on(int cpu, struct workqueue_struct *wq,
>   struct delayed_work *dwork, unsigned long delay);
>extern bool queue_rcu_work(struct workqueue_struct *wq, struct rcu_work *rwork);
>
>extern void flush_workqueue(struct workqueue_struct *wq);
>extern void drain_workqueue(struct workqueue_struct *wq);
>
>extern int schedule_on_each_cpu(work_func_t func);
>
>int execute_in_process_context(work_func_t fn, struct execute_work *);
>
>extern bool flush_work(struct work_struct *work);
>extern bool cancel_work(struct work_struct *work);
>extern bool cancel_work_sync(struct work_struct *work);
>
>extern bool flush_delayed_work(struct delayed_work *dwork);
>extern bool cancel_delayed_work(struct delayed_work *dwork);
>extern bool cancel_delayed_work_sync(struct delayed_work *dwork);
>
>extern bool flush_rcu_work(struct rcu_work *rwork);
>
>extern void workqueue_set_max_active(struct workqueue_struct *wq,
>         int max_active);
>extern struct work_struct *current_work(void);
>extern bool current_is_workqueue_rescuer(void);
>extern bool workqueue_congested(int cpu, struct workqueue_struct *wq);
>extern unsigned int work_busy(struct work_struct *work);
>extern __attribute__((__format__(printf, 1, 2))) void set_worker_desc(const char *fmt, ...);
>extern void print_worker_info(const char *log_lvl, struct task_struct *task);
>extern void show_workqueue_state(void);
>extern void wq_worker_comm(char *buf, size_t size, struct task_struct *task);
># 500 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool queue_work(struct workqueue_struct *wq,
>         struct work_struct *work)
>{
> return queue_work_on(WORK_CPU_UNBOUND, wq, work);
>}
># 514 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool queue_delayed_work(struct workqueue_struct *wq,
>          struct delayed_work *dwork,
>          unsigned long delay)
>{
> return queue_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
>}
># 529 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mod_delayed_work(struct workqueue_struct *wq,
>        struct delayed_work *dwork,
>        unsigned long delay)
>{
> return mod_delayed_work_on(WORK_CPU_UNBOUND, wq, dwork, delay);
>}
># 543 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool schedule_work_on(int cpu, struct work_struct *work)
>{
> return queue_work_on(cpu, system_wq, work);
>}
># 562 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool schedule_work(struct work_struct *work)
>{
> return queue_work(system_wq, work);
>}
># 591 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_scheduled_work(void)
>{
> flush_workqueue(system_wq);
>}
># 605 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool schedule_delayed_work_on(int cpu, struct delayed_work *dwork,
>         unsigned long delay)
>{
> return queue_delayed_work_on(cpu, system_wq, dwork, delay);
>}
># 619 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool schedule_delayed_work(struct delayed_work *dwork,
>      unsigned long delay)
>{
> return queue_delayed_work(system_wq, dwork, delay);
>}
># 635 "/usr/src/linux-5.14.21-150500.53/include/linux/workqueue.h"
>long work_on_cpu(int cpu, long (*fn)(void *), void *arg);
>long work_on_cpu_safe(int cpu, long (*fn)(void *), void *arg);
>
>
>
>extern void freeze_workqueues_begin(void);
>extern bool freeze_workqueues_busy(void);
>extern void thaw_workqueues(void);
>
>
>
>int workqueue_sysfs_register(struct workqueue_struct *wq);
>
>
>
>
>
>
>void wq_watchdog_touch(int cpu);
>
>
>
>
>
>int workqueue_prepare_cpu(unsigned int cpu);
>int workqueue_online_cpu(unsigned int cpu);
>int workqueue_offline_cpu(unsigned int cpu);
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) workqueue_init_early(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) workqueue_init(void);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_segcblist.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_segcblist.h"
>struct rcu_cblist {
> struct callback_head *head;
> struct callback_head **tail;
> long len;
>};
># 183 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_segcblist.h"
>struct rcu_segcblist {
> struct callback_head *head;
> struct callback_head **tails[4];
> unsigned long gp_seq[4];
>
> atomic_long_t len;
>
>
>
> long seglen[4];
> u8 flags;
>};
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h" 2
>
>struct srcu_struct;
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"
>int init_srcu_struct(struct srcu_struct *ssp);
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/srcutree.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/srcutree.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_node_tree.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/srcutree.h" 2
>
>
>struct srcu_node;
>struct srcu_struct;
>
>
>
>
>
>struct srcu_data {
>
> unsigned long srcu_lock_count[2];
> unsigned long srcu_unlock_count[2];
>
>
> spinlock_t lock __attribute__((__aligned__(1 << (6))));
> struct rcu_segcblist srcu_cblist;
> unsigned long srcu_gp_seq_needed;
> unsigned long srcu_gp_seq_needed_exp;
> bool srcu_cblist_invoking;
> struct timer_list delay_work;
> struct work_struct work;
> struct callback_head srcu_barrier_head;
> struct srcu_node *mynode;
> unsigned long grpmask;
>
> int cpu;
> struct srcu_struct *ssp;
>};
>
>
>
>
>struct srcu_node {
> spinlock_t lock;
> unsigned long srcu_have_cbs[4];
>
>
> unsigned long srcu_data_have_cbs[4];
>
> unsigned long srcu_gp_seq_needed_exp;
> struct srcu_node *srcu_parent;
> int grplo;
> int grphi;
>};
>
>
>
>
>struct srcu_struct {
> struct srcu_node node[(1 + (((8192) + (((16) * 64)) - 1) / (((16) * 64))) + (((8192) + ((16)) - 1) / ((16))))];
> struct srcu_node *level[3 + 1];
>
> struct mutex srcu_cb_mutex;
> spinlock_t lock;
> struct mutex srcu_gp_mutex;
> unsigned int srcu_idx;
> unsigned long srcu_gp_seq;
> unsigned long srcu_gp_seq_needed;
> unsigned long srcu_gp_seq_needed_exp;
> unsigned long srcu_last_gp_end;
> struct srcu_data *sda;
> unsigned long srcu_barrier_seq;
> struct mutex srcu_barrier_mutex;
> struct completion srcu_barrier_completion;
>
> atomic_t srcu_barrier_cpu_cnt;
>
>
> struct delayed_work work;
> struct lockdep_map dep_map;
>};
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/srcutree.h"
>void synchronize_srcu_expedited(struct srcu_struct *ssp);
>void srcu_barrier(struct srcu_struct *ssp);
>void srcu_torture_stats_print(struct srcu_struct *ssp, char *tt, char *tf);
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h" 2
>
>
>
>
>
>
>
>void call_srcu(struct srcu_struct *ssp, struct callback_head *head,
>  void (*func)(struct callback_head *head));
>void cleanup_srcu_struct(struct srcu_struct *ssp);
>int __srcu_read_lock(struct srcu_struct *ssp) ;
>void __srcu_read_unlock(struct srcu_struct *ssp, int idx) ;
>void synchronize_srcu(struct srcu_struct *ssp);
>unsigned long get_state_synchronize_srcu(struct srcu_struct *ssp);
>unsigned long start_poll_synchronize_srcu(struct srcu_struct *ssp);
>bool poll_state_synchronize_srcu(struct srcu_struct *ssp, unsigned long cookie);
>
>
>void srcu_init(void);
># 100 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int srcu_read_lock_held(const struct srcu_struct *ssp)
>{
> return 1;
>}
># 159 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int srcu_read_lock(struct srcu_struct *ssp)
>{
> int retval;
>
> retval = __srcu_read_lock(ssp);
> do { } while (0);
> return retval;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) int
>srcu_read_lock_notrace(struct srcu_struct *ssp)
>{
> int retval;
>
> retval = __srcu_read_lock(ssp);
> return retval;
>}
># 185 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void srcu_read_unlock(struct srcu_struct *ssp, int idx)
>
>{
> ({ int __ret_warn_on = !!(idx & ~0x1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"), "i" (188), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("103" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "103" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> do { } while (0);
> __srcu_read_unlock(ssp, idx);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((no_instrument_function)) void
>srcu_read_unlock_notrace(struct srcu_struct *ssp, int idx)
>{
> __srcu_read_unlock(ssp, idx);
>}
># 209 "/usr/src/linux-5.14.21-150500.53/include/linux/srcu.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void smp_mb__after_srcu_read_unlock(void)
>{
>
>}
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h" 2
># 49 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h"
>struct notifier_block;
>
>typedef int (*notifier_fn_t)(struct notifier_block *nb,
>   unsigned long action, void *data);
>
>struct notifier_block {
> notifier_fn_t notifier_call;
> struct notifier_block *next;
> int priority;
>};
>
>struct atomic_notifier_head {
> spinlock_t lock;
> struct notifier_block *head;
>};
>
>struct blocking_notifier_head {
> struct rw_semaphore rwsem;
> struct notifier_block *head;
>};
>
>struct raw_notifier_head {
> struct notifier_block *head;
>};
>
>struct srcu_notifier_head {
> struct mutex mutex;
> struct srcu_struct srcu;
> struct notifier_block *head;
>};
># 93 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h"
>extern void srcu_init_notifier_head(struct srcu_notifier_head *nh);
># 144 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h"
>extern int atomic_notifier_chain_register(struct atomic_notifier_head *nh,
>  struct notifier_block *nb);
>extern int blocking_notifier_chain_register(struct blocking_notifier_head *nh,
>  struct notifier_block *nb);
>extern int raw_notifier_chain_register(struct raw_notifier_head *nh,
>  struct notifier_block *nb);
>extern int srcu_notifier_chain_register(struct srcu_notifier_head *nh,
>  struct notifier_block *nb);
>
>extern int atomic_notifier_chain_unregister(struct atomic_notifier_head *nh,
>  struct notifier_block *nb);
>extern int blocking_notifier_chain_unregister(struct blocking_notifier_head *nh,
>  struct notifier_block *nb);
>extern int raw_notifier_chain_unregister(struct raw_notifier_head *nh,
>  struct notifier_block *nb);
>extern int srcu_notifier_chain_unregister(struct srcu_notifier_head *nh,
>  struct notifier_block *nb);
>
>extern int atomic_notifier_call_chain(struct atomic_notifier_head *nh,
>  unsigned long val, void *v);
>extern int blocking_notifier_call_chain(struct blocking_notifier_head *nh,
>  unsigned long val, void *v);
>extern int raw_notifier_call_chain(struct raw_notifier_head *nh,
>  unsigned long val, void *v);
>extern int srcu_notifier_call_chain(struct srcu_notifier_head *nh,
>  unsigned long val, void *v);
>
>extern int atomic_notifier_call_chain_robust(struct atomic_notifier_head *nh,
>  unsigned long val_up, unsigned long val_down, void *v);
>extern int blocking_notifier_call_chain_robust(struct blocking_notifier_head *nh,
>  unsigned long val_up, unsigned long val_down, void *v);
>extern int raw_notifier_call_chain_robust(struct raw_notifier_head *nh,
>  unsigned long val_up, unsigned long val_down, void *v);
># 189 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int notifier_from_errno(int err)
>{
> if (err)
>  return 0x8000 | (0x0001 - err);
>
> return 0x0001;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int notifier_to_errno(int ret)
>{
> ret &= ~0x8000;
> return ret > 0x0001 ? 0x0001 - ret : 0;
>}
># 233 "/usr/src/linux-5.14.21-150500.53/include/linux/notifier.h"
>extern struct blocking_notifier_head reboot_notifier_list;
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uprobes.h" 2
>
>typedef u8 uprobe_opcode_t;
>
>
>
>
>
>
>
>struct uprobe_xol_ops;
>
>struct arch_uprobe {
> union {
>  u8 insn[16];
>  u8 ixol[16];
> };
>
> const struct uprobe_xol_ops *ops;
>
> union {
>  struct {
>   s32 offs;
>   u8 ilen;
>   u8 opc1;
>  } branch;
>  struct {
>   u8 fixups;
>   u8 ilen;
>  } defparam;
>  struct {
>   u8 reg_offset;
>   u8 ilen;
>  } push;
> };
>};
>
>struct arch_uprobe_task {
>
> unsigned long saved_scratch_register;
>
> unsigned int saved_trap_nr;
> unsigned int saved_tf;
>};
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/uprobes.h" 2
>
>enum uprobe_task_state {
> UTASK_RUNNING,
> UTASK_SSTEP,
> UTASK_SSTEP_ACK,
> UTASK_SSTEP_TRAPPED,
>};
>
>
>
>
>struct uprobe_task {
> enum uprobe_task_state state;
>
> union {
>  struct {
>   struct arch_uprobe_task autask;
>   unsigned long vaddr;
>  };
>
>  struct {
>   struct callback_head dup_xol_work;
>   unsigned long dup_xol_addr;
>  };
> };
>
> struct uprobe *active_uprobe;
> unsigned long xol_vaddr;
>
> struct return_instance *return_instances;
> unsigned int depth;
>};
>
>struct return_instance {
> struct uprobe *uprobe;
> unsigned long func;
> unsigned long stack;
> unsigned long orig_ret_vaddr;
> bool chained;
>
> struct return_instance *next;
>};
>
>enum rp_check {
> RP_CHECK_CALL,
> RP_CHECK_CHAIN_CALL,
> RP_CHECK_RET,
>};
>
>struct xol_area;
>
>struct uprobes_state {
> struct xol_area *xol_area;
>};
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) uprobes_init(void);
>extern int set_swbp(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
>extern int set_orig_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long vaddr);
>extern bool is_swbp_insn(uprobe_opcode_t *insn);
>extern bool is_trap_insn(uprobe_opcode_t *insn);
>extern unsigned long uprobe_get_swbp_addr(struct pt_regs *regs);
>extern unsigned long uprobe_get_trap_addr(struct pt_regs *regs);
>extern int uprobe_write_opcode(struct arch_uprobe *auprobe, struct mm_struct *mm, unsigned long vaddr, uprobe_opcode_t);
>extern int uprobe_register(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
>extern int uprobe_register_refctr(struct inode *inode, loff_t offset, loff_t ref_ctr_offset, struct uprobe_consumer *uc);
>extern int uprobe_apply(struct inode *inode, loff_t offset, struct uprobe_consumer *uc, bool);
>extern void uprobe_unregister(struct inode *inode, loff_t offset, struct uprobe_consumer *uc);
>extern int uprobe_mmap(struct vm_area_struct *vma);
>extern void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned long end);
>extern void uprobe_start_dup_mmap(void);
>extern void uprobe_end_dup_mmap(void);
>extern void uprobe_dup_mmap(struct mm_struct *oldmm, struct mm_struct *newmm);
>extern void uprobe_free_utask(struct task_struct *t);
>extern void uprobe_copy_process(struct task_struct *t, unsigned long flags);
>extern int uprobe_post_sstep_notifier(struct pt_regs *regs);
>extern int uprobe_pre_sstep_notifier(struct pt_regs *regs);
>extern void uprobe_notify_resume(struct pt_regs *regs);
>extern bool uprobe_deny_signal(void);
>extern bool arch_uprobe_skip_sstep(struct arch_uprobe *aup, struct pt_regs *regs);
>extern void uprobe_clear_state(struct mm_struct *mm);
>extern int arch_uprobe_analyze_insn(struct arch_uprobe *aup, struct mm_struct *mm, unsigned long addr);
>extern int arch_uprobe_pre_xol(struct arch_uprobe *aup, struct pt_regs *regs);
>extern int arch_uprobe_post_xol(struct arch_uprobe *aup, struct pt_regs *regs);
>extern bool arch_uprobe_xol_was_trapped(struct task_struct *tsk);
>extern int arch_uprobe_exception_notify(struct notifier_block *self, unsigned long val, void *data);
>extern void arch_uprobe_abort_xol(struct arch_uprobe *aup, struct pt_regs *regs);
>extern unsigned long arch_uretprobe_hijack_return_addr(unsigned long trampoline_vaddr, struct pt_regs *regs);
>extern bool arch_uretprobe_is_alive(struct return_instance *ret, enum rp_check ctx, struct pt_regs *regs);
>extern bool arch_uprobe_ignore(struct arch_uprobe *aup, struct pt_regs *regs);
>extern void arch_uprobe_copy_ixol(struct page *page, unsigned long vaddr,
>      void *src, unsigned long len);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmu.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmu.h"
>typedef struct {
>
>
>
>
> u64 ctx_id;
># 34 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmu.h"
> atomic64_t tlb_gen;
>
>
> struct rw_semaphore ldt_usr_sem;
> struct ldt_struct *ldt;
>
>
>
> unsigned short flags;
>
>
> struct mutex lock;
> void *vdso;
> const struct vdso_image *vdso_image;
>
> atomic_t perf_rdpmc_allowed;
>
>
>
>
>
> u16 pkey_allocation_map;
> s16 execute_only_pkey;
>
> void *suse_kabi_padding;
>} mm_context_t;
>
>
>
>
>
>
>
>void leave_mm(int cpu);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h" 2
># 29 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>struct address_space;
>struct mem_cgroup;
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>struct page {
> unsigned long flags;
>
>
>
>
>
>
>
> union {
>  struct {
>
>
>
>
>
>   struct list_head lru;
>
>   struct address_space *mapping;
>   unsigned long index;
>
>
>
>
>
>
>   unsigned long private;
>  };
>  struct {
>
>
>
>
>   unsigned long pp_magic;
>   struct page_pool *pp;
>   unsigned long _pp_mapping_pad;
>   unsigned long dma_addr;
>   union {
>
>
>
>
>    unsigned long dma_addr_upper;
>
>
>
>
>    atomic_long_t pp_frag_count;
>   };
>  };
>  struct {
>   union {
>    struct list_head slab_list;
>    struct {
>     struct page *next;
>
>     int pages;
>     int pobjects;
>
>
>
>
>    };
>   };
>   struct kmem_cache *slab_cache;
>
>   void *freelist;
>   union {
>    void *s_mem;
>    unsigned long counters;
>    struct {
>     unsigned inuse:16;
>     unsigned objects:15;
>     unsigned frozen:1;
>    };
>   };
>  };
>  struct {
>   unsigned long compound_head;
>
>
>   unsigned char compound_dtor;
>   unsigned char compound_order;
>   atomic_t compound_mapcount;
>   unsigned int compound_nr;
>  };
>  struct {
>   unsigned long _compound_pad_1;
>   atomic_t hpage_pinned_refcount;
>
>   struct list_head deferred_list;
>  };
>  struct {
>   unsigned long _pt_pad_1;
>   pgtable_t pmd_huge_pte;
>   unsigned long _pt_pad_2;
>   union {
>    struct mm_struct *pt_mm;
>    atomic_t pt_frag_refcount;
>   };
>
>
>
>   spinlock_t ptl;
>
>  };
>  struct {
>
>   struct dev_pagemap *pgmap;
>   void *zone_device_data;
># 191 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  };
>
>
>  struct callback_head callback_head;
> };
>
> union {
>
>
>
>
>  atomic_t _mapcount;
>
>
>
>
>
>
>
>  unsigned int page_type;
>
>  unsigned int active;
>  int units;
> };
>
>
> atomic_t _refcount;
>
>
> unsigned long memcg_data;
># 241 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>} __attribute__((__aligned__(2 * sizeof(unsigned long))));
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) atomic_t *compound_mapcount_ptr(struct page *page)
>{
> return &page[1].compound_mapcount;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) atomic_t *compound_pincount_ptr(struct page *page)
>{
> return &page[2].hpage_pinned_refcount;
>}
># 263 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_private(struct page *page, unsigned long private)
>{
> page->private = private;
>}
>
>struct page_frag_cache {
> void * va;
>
> __u16 offset;
> __u16 size;
>
>
>
>
>
>
> unsigned int pagecnt_bias;
> bool pfmemalloc;
>};
>
>typedef unsigned long vm_flags_t;
>
>
>
>
>
>
>struct vm_region {
> struct rb_node vm_rb;
> vm_flags_t vm_flags;
> unsigned long vm_start;
> unsigned long vm_end;
> unsigned long vm_top;
> unsigned long vm_pgoff;
> struct file *vm_file;
>
> int vm_usage;
> bool vm_icache_flushed : 1;
>
>};
>
>
>
>struct vm_userfaultfd_ctx {
> struct userfaultfd_ctx *ctx;
>};
># 320 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>struct vm_area_struct {
>
>
> unsigned long vm_start;
> unsigned long vm_end;
>
>
>
> struct vm_area_struct *vm_next, *vm_prev;
>
> struct rb_node vm_rb;
>
>
>
>
>
>
>
> unsigned long rb_subtree_gap;
>
>
>
> struct mm_struct *vm_mm;
>
>
>
>
>
> pgprot_t vm_page_prot;
> unsigned long vm_flags;
>
>
>
>
>
> struct {
>  struct rb_node rb;
>  unsigned long rb_subtree_last;
> } shared;
>
>
>
>
>
>
>
> struct list_head anon_vma_chain;
>
> struct anon_vma *anon_vma;
>
>
> const struct vm_operations_struct *vm_ops;
>
>
> unsigned long vm_pgoff;
>
> struct file * vm_file;
> void * vm_private_data;
>
>
> atomic_long_t swap_readahead_info;
>
>
>
>
>
> struct mempolicy *vm_policy;
>
> struct vm_userfaultfd_ctx vm_userfaultfd_ctx;
> void *suse_kabi_padding;
>} __attribute__((__designated_init__));
>
>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 kioctx_table;
>struct mm_struct {
> struct {
>  struct vm_area_struct *mmap;
>  struct rb_root mm_rb;
>  u64 vmacache_seqnum;
>
>  unsigned long (*get_unmapped_area) (struct file *filp,
>    unsigned long addr, unsigned long len,
>    unsigned long pgoff, unsigned long flags);
>
>  unsigned long mmap_base;
>  unsigned long mmap_legacy_base;
>
>
>  unsigned long mmap_compat_base;
>  unsigned long mmap_compat_legacy_base;
>
>  unsigned long task_size;
>  unsigned long highest_vm_end;
>  pgd_t * pgd;
># 432 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  atomic_t membarrier_state;
># 444 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  atomic_t mm_users;
># 453 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  atomic_t mm_count;
>
>
>  atomic_long_t pgtables_bytes;
>
>  int map_count;
>
>  spinlock_t page_table_lock;
># 475 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  struct rw_semaphore mmap_lock;
>
>  struct list_head mmlist;
>
>
>
>
>
>
>  unsigned long hiwater_rss;
>  unsigned long hiwater_vm;
>
>  unsigned long total_vm;
>  unsigned long locked_vm;
>  atomic64_t pinned_vm;
>  unsigned long data_vm;
>  unsigned long exec_vm;
>  unsigned long stack_vm;
>  unsigned long def_flags;
>
>
>
>
>
>
>  seqcount_t write_protect_seq;
>
>  spinlock_t arg_lock;
>
>  unsigned long start_code, end_code, start_data, end_data;
>  unsigned long start_brk, brk, start_stack;
>  unsigned long arg_start, arg_end, env_start, env_end;
>
>  unsigned long saved_auxv[(2*(3 + 20 + 1))];
>
>
>
>
>
>  struct mm_rss_stat rss_stat;
>
>  struct linux_binfmt *binfmt;
>
>
>  mm_context_t context;
>
>  unsigned long flags;
>
>  struct core_state *core_state;
>
>
>  spinlock_t ioctx_lock;
>  struct kioctx_table *ioctx_table;
># 540 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  struct task_struct *owner;
>
>  struct user_namespace *user_ns;
>
>
>  struct file *exe_file;
>
>  struct mmu_notifier_subscriptions *notifier_subscriptions;
># 558 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>  unsigned long numa_next_scan;
>
>
>  unsigned long numa_scan_offset;
>
>
>  int numa_scan_seq;
>
>
>
>
>
>
>  atomic_t tlb_flush_pending;
>
>
>  bool tlb_flush_batched;
>
>  struct uprobes_state uprobes_state;
>
>
>
>
>  atomic_long_t hugetlb_usage;
>
>  struct work_struct async_put_work;
>
>
>  u32 pasid;
>
>  void *suse_kabi_padding;
> } __attribute__((__designated_init__));
>
>
>
>
>
> unsigned long cpu_bitmap[];
>};
>
>extern struct mm_struct init_mm;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_init_cpumask(struct mm_struct *mm)
>{
> unsigned long cpu_bitmap = (unsigned long)mm;
>
> cpu_bitmap += __builtin_offsetof(struct mm_struct, cpu_bitmap);
> cpumask_clear((struct cpumask *)cpu_bitmap);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) cpumask_t *mm_cpumask(struct mm_struct *mm)
>{
> return (struct cpumask *)&mm->cpu_bitmap;
>}
>
>struct mmu_gather;
>extern void tlb_gather_mmu(struct mmu_gather *tlb, struct mm_struct *mm);
>extern void tlb_gather_mmu_fullmm(struct mmu_gather *tlb, struct mm_struct *mm);
>extern void tlb_finish_mmu(struct mmu_gather *tlb);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_tlb_flush_pending(struct mm_struct *mm)
>{
> atomic_set(&mm->tlb_flush_pending, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inc_tlb_flush_pending(struct mm_struct *mm)
>{
> atomic_inc(&mm->tlb_flush_pending);
># 664 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dec_tlb_flush_pending(struct mm_struct *mm)
>{
># 676 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
> atomic_dec(&mm->tlb_flush_pending);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mm_tlb_flush_pending(struct mm_struct *mm)
>{
># 689 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
> return atomic_read(&mm->tlb_flush_pending);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mm_tlb_flush_nested(struct mm_struct *mm)
>{
>
>
>
>
>
>
>
> return atomic_read(&mm->tlb_flush_pending) > 1;
>}
>
>struct vm_fault;
>
>
>
>
>
>
>typedef unsigned int vm_fault_t;
># 738 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>enum vm_fault_reason {
> VM_FAULT_OOM = ( vm_fault_t)0x000001,
> VM_FAULT_SIGBUS = ( vm_fault_t)0x000002,
> VM_FAULT_MAJOR = ( vm_fault_t)0x000004,
> VM_FAULT_WRITE = ( vm_fault_t)0x000008,
> VM_FAULT_HWPOISON = ( vm_fault_t)0x000010,
> VM_FAULT_HWPOISON_LARGE = ( vm_fault_t)0x000020,
> VM_FAULT_SIGSEGV = ( vm_fault_t)0x000040,
> VM_FAULT_NOPAGE = ( vm_fault_t)0x000100,
> VM_FAULT_LOCKED = ( vm_fault_t)0x000200,
> VM_FAULT_RETRY = ( vm_fault_t)0x000400,
> VM_FAULT_FALLBACK = ( vm_fault_t)0x000800,
> VM_FAULT_DONE_COW = ( vm_fault_t)0x001000,
> VM_FAULT_NEEDDSYNC = ( vm_fault_t)0x002000,
> VM_FAULT_HINDEX_MASK = ( vm_fault_t)0x0f0000,
>};
># 778 "/usr/src/linux-5.14.21-150500.53/include/linux/mm_types.h"
>struct vm_special_mapping {
> const char *name;
>
>
>
>
>
>
>
> struct page **pages;
>
>
>
>
>
> vm_fault_t (*fault)(const struct vm_special_mapping *sm,
>    struct vm_area_struct *vma,
>    struct vm_fault *vmf);
>
> int (*mremap)(const struct vm_special_mapping *sm,
>       struct vm_area_struct *new_vma);
>};
>
>enum tlb_flush_reason {
> TLB_FLUSH_ON_TASK_SWITCH,
> TLB_REMOTE_SHOOTDOWN,
> TLB_LOCAL_SHOOTDOWN,
> TLB_LOCAL_MM_SHOOTDOWN,
> TLB_REMOTE_SEND_IPI,
> NR_TLB_FLUSH_REASONS,
>};
>
>
>
>
>
>typedef struct {
> unsigned long val;
>} swp_entry_t;
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h" 1
># 103 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>enum pageflags {
> PG_locked,
> PG_referenced,
> PG_uptodate,
> PG_dirty,
> PG_lru,
> PG_active,
> PG_workingset,
> PG_waiters,
> PG_error,
> PG_slab,
> PG_owner_priv_1,
> PG_arch_1,
> PG_reserved,
> PG_private,
> PG_private_2,
> PG_writeback,
> PG_head,
> PG_mappedtodisk,
> PG_reclaim,
> PG_swapbacked,
> PG_unevictable,
>
> PG_mlocked,
>
>
> PG_uncached,
>
>
> PG_hwpoison,
>
>
>
>
>
>
> PG_arch_2,
>
>
>
>
> __NR_PAGEFLAGS,
>
>
> PG_checked = PG_owner_priv_1,
>
>
> PG_swapcache = PG_owner_priv_1,
>
>
>
>
>
> PG_fscache = PG_private_2,
>
>
>
> PG_pinned = PG_owner_priv_1,
>
> PG_savepinned = PG_dirty,
>
> PG_foreign = PG_owner_priv_1,
>
> PG_xen_remapped = PG_owner_priv_1,
>
>
> PG_slob_free = PG_private,
>
>
> PG_double_map = PG_workingset,
>
>
>
>
>
>
>
> PG_has_hwpoisoned = PG_mappedtodisk,
>
>
>
> PG_isolated = PG_reclaim,
>
>
> PG_reported = PG_uptodate,
>};
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long _compound_head(const struct page *page)
>{
> unsigned long head = ({ do { extern void __compiletime_assert_104(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->compound_head) == sizeof(char) || sizeof(page->compound_head) == sizeof(short) || sizeof(page->compound_head) == sizeof(int) || sizeof(page->compound_head) == sizeof(long)) || sizeof(page->compound_head) == sizeof(long long))) __compiletime_assert_104(); } while (0); (*(const volatile typeof( _Generic((page->compound_head), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (page->compound_head))) *)&(page->compound_head)); });
>
> if (__builtin_expect(!!(head & 1), 0))
>  return head - 1;
> return (unsigned long)page;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageTail(struct page *page)
>{
> return ({ do { extern void __compiletime_assert_105(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->compound_head) == sizeof(char) || sizeof(page->compound_head) == sizeof(short) || sizeof(page->compound_head) == sizeof(int) || sizeof(page->compound_head) == sizeof(long)) || sizeof(page->compound_head) == sizeof(long long))) __compiletime_assert_105(); } while (0); (*(const volatile typeof( _Generic((page->compound_head), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (page->compound_head))) *)&(page->compound_head)); }) & 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageCompound(struct page *page)
>{
> return test_bit(PG_head, &page->flags) || PageTail(page);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PagePoisoned(const struct page *page)
>{
> return page->flags == -1l;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_init_poison(struct page *page, size_t size)
>{
>}
># 342 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageLocked(struct page *page) { return test_bit(PG_locked, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageLocked(struct page *page) { __set_bit(PG_locked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageLocked(struct page *page) { __clear_bit(PG_locked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageWaiters(struct page *page) { return test_bit(PG_waiters, &({ ((void)(sizeof(( long)(PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageWaiters(struct page *page) { set_bit(PG_waiters, &({ ((void)(sizeof(( long)(PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageWaiters(struct page *page) { clear_bit(PG_waiters, &({ ((void)(sizeof(( long)(PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageWaiters(struct page *page) { __clear_bit(PG_waiters, &({ ((void)(sizeof(( long)(PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageError(struct page *page) { return test_bit(PG_error, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageError(struct page *page) { set_bit(PG_error, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageError(struct page *page) { clear_bit(PG_error, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageError(struct page *page) { return test_and_clear_bit(PG_error, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageReferenced(struct page *page) { return test_bit(PG_referenced, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageReferenced(struct page *page) { set_bit(PG_referenced, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageReferenced(struct page *page) { clear_bit(PG_referenced, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageReferenced(struct page *page) { return test_and_clear_bit(PG_referenced, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageReferenced(struct page *page) { __set_bit(PG_referenced, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageDirty(struct page *page) { return test_bit(PG_dirty, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageDirty(struct page *page) { set_bit(PG_dirty, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageDirty(struct page *page) { clear_bit(PG_dirty, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPageDirty(struct page *page) { return test_and_set_bit(PG_dirty, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageDirty(struct page *page) { return test_and_clear_bit(PG_dirty, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageDirty(struct page *page) { __clear_bit(PG_dirty, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageLRU(struct page *page) { return test_bit(PG_lru, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageLRU(struct page *page) { set_bit(PG_lru, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageLRU(struct page *page) { clear_bit(PG_lru, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageLRU(struct page *page) { __clear_bit(PG_lru, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageLRU(struct page *page) { return test_and_clear_bit(PG_lru, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageActive(struct page *page) { return test_bit(PG_active, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageActive(struct page *page) { set_bit(PG_active, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageActive(struct page *page) { clear_bit(PG_active, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageActive(struct page *page) { __clear_bit(PG_active, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageActive(struct page *page) { return test_and_clear_bit(PG_active, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageWorkingset(struct page *page) { return test_bit(PG_workingset, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageWorkingset(struct page *page) { set_bit(PG_workingset, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageWorkingset(struct page *page) { clear_bit(PG_workingset, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageWorkingset(struct page *page) { return test_and_clear_bit(PG_workingset, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageSlab(struct page *page) { return test_bit(PG_slab, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageSlab(struct page *page) { __set_bit(PG_slab, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageSlab(struct page *page) { __clear_bit(PG_slab, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageSlobFree(struct page *page) { return test_bit(PG_slob_free, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageSlobFree(struct page *page) { __set_bit(PG_slob_free, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageSlobFree(struct page *page) { __clear_bit(PG_slob_free, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageChecked(struct page *page) { return test_bit(PG_checked, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageChecked(struct page *page) { set_bit(PG_checked, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageChecked(struct page *page) { clear_bit(PG_checked, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PagePinned(struct page *page) { return test_bit(PG_pinned, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPagePinned(struct page *page) { set_bit(PG_pinned, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPagePinned(struct page *page) { clear_bit(PG_pinned, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPagePinned(struct page *page) { return test_and_set_bit(PG_pinned, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPagePinned(struct page *page) { return test_and_clear_bit(PG_pinned, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageSavePinned(struct page *page) { return test_bit(PG_savepinned, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageSavePinned(struct page *page) { set_bit(PG_savepinned, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageSavePinned(struct page *page) { clear_bit(PG_savepinned, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); };
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageForeign(struct page *page) { return test_bit(PG_foreign, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageForeign(struct page *page) { set_bit(PG_foreign, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageForeign(struct page *page) { clear_bit(PG_foreign, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); };
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageXenRemapped(struct page *page) { return test_bit(PG_xen_remapped, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageXenRemapped(struct page *page) { set_bit(PG_xen_remapped, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageXenRemapped(struct page *page) { clear_bit(PG_xen_remapped, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageXenRemapped(struct page *page) { return test_and_clear_bit(PG_xen_remapped, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageReserved(struct page *page) { return test_bit(PG_reserved, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageReserved(struct page *page) { set_bit(PG_reserved, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageReserved(struct page *page) { clear_bit(PG_reserved, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageReserved(struct page *page) { __clear_bit(PG_reserved, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageReserved(struct page *page) { __set_bit(PG_reserved, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageSwapBacked(struct page *page) { return test_bit(PG_swapbacked, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageSwapBacked(struct page *page) { set_bit(PG_swapbacked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageSwapBacked(struct page *page) { clear_bit(PG_swapbacked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageSwapBacked(struct page *page) { __clear_bit(PG_swapbacked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageSwapBacked(struct page *page) { __set_bit(PG_swapbacked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PagePrivate(struct page *page) { return test_bit(PG_private, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPagePrivate(struct page *page) { set_bit(PG_private, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPagePrivate(struct page *page) { clear_bit(PG_private, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PagePrivate2(struct page *page) { return test_bit(PG_private_2, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPagePrivate2(struct page *page) { set_bit(PG_private_2, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPagePrivate2(struct page *page) { clear_bit(PG_private_2, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPagePrivate2(struct page *page) { return test_and_set_bit(PG_private_2, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPagePrivate2(struct page *page) { return test_and_clear_bit(PG_private_2, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageOwnerPriv1(struct page *page) { return test_bit(PG_owner_priv_1, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageOwnerPriv1(struct page *page) { set_bit(PG_owner_priv_1, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageOwnerPriv1(struct page *page) { clear_bit(PG_owner_priv_1, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageOwnerPriv1(struct page *page) { return test_and_clear_bit(PG_owner_priv_1, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageWriteback(struct page *page) { return test_bit(PG_writeback, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPageWriteback(struct page *page) { return test_and_set_bit(PG_writeback, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageWriteback(struct page *page) { return test_and_clear_bit(PG_writeback, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageMappedToDisk(struct page *page) { return test_bit(PG_mappedtodisk, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageMappedToDisk(struct page *page) { set_bit(PG_mappedtodisk, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageMappedToDisk(struct page *page) { clear_bit(PG_mappedtodisk, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageReclaim(struct page *page) { return test_bit(PG_reclaim, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageReclaim(struct page *page) { set_bit(PG_reclaim, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageReclaim(struct page *page) { clear_bit(PG_reclaim, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageReclaim(struct page *page) { return test_and_clear_bit(PG_reclaim, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageReadahead(struct page *page) { return test_bit(PG_reclaim, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageReadahead(struct page *page) { set_bit(PG_reclaim, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageReadahead(struct page *page) { clear_bit(PG_reclaim, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageReadahead(struct page *page) { return test_and_clear_bit(PG_reclaim, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
># 406 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageHighMem(const struct page *page) { return 0; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void SetPageHighMem(struct page *page) { } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ClearPageHighMem(struct page *page) { }
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageSwapCache(struct page *page)
>{
>
> page = ((typeof(page))_compound_head(page));
>
> return PageSwapBacked(page) && test_bit(PG_swapcache, &page->flags);
>
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageSwapCache(struct page *page) { set_bit(PG_swapcache, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageSwapCache(struct page *page) { clear_bit(PG_swapcache, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageUnevictable(struct page *page) { return test_bit(PG_unevictable, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageUnevictable(struct page *page) { set_bit(PG_unevictable, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageUnevictable(struct page *page) { clear_bit(PG_unevictable, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageUnevictable(struct page *page) { __clear_bit(PG_unevictable, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageUnevictable(struct page *page) { return test_and_clear_bit(PG_unevictable, &({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); })->flags); }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageMlocked(struct page *page) { return test_bit(PG_mlocked, &({ ((void)(sizeof(( long)(0 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageMlocked(struct page *page) { set_bit(PG_mlocked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageMlocked(struct page *page) { clear_bit(PG_mlocked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageMlocked(struct page *page) { __clear_bit(PG_mlocked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPageMlocked(struct page *page) { return test_and_set_bit(PG_mlocked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageMlocked(struct page *page) { return test_and_clear_bit(PG_mlocked, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageUncached(struct page *page) { return test_bit(PG_uncached, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageUncached(struct page *page) { set_bit(PG_uncached, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageUncached(struct page *page) { clear_bit(PG_uncached, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageHWPoison(struct page *page) { return test_bit(PG_hwpoison, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageHWPoison(struct page *page) { set_bit(PG_hwpoison, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageHWPoison(struct page *page) { clear_bit(PG_hwpoison, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPageHWPoison(struct page *page) { return test_and_set_bit(PG_hwpoison, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageHWPoison(struct page *page) { return test_and_clear_bit(PG_hwpoison, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
>
>extern bool take_page_off_buddy(struct page *page);
># 463 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageSkipKASanPoison(const struct page *page) { return 0; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void SetPageSkipKASanPoison(struct page *page) { } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ClearPageSkipKASanPoison(struct page *page) { }
># 472 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageReported(struct page *page) { return test_bit(PG_reported, &({ ((void)(sizeof(( long)(0 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageReported(struct page *page) { __set_bit(PG_reported, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageReported(struct page *page) { __clear_bit(PG_reported, &({ ((void)(sizeof(( long)(1 && PageCompound(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; }); })->flags); }
># 496 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageMappingFlags(struct page *page)
>{
> return ((unsigned long)page->mapping & (0x1 | 0x2)) != 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageAnon(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
> return ((unsigned long)page->mapping & 0x1) != 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int __PageMovable(struct page *page)
>{
> return ((unsigned long)page->mapping & (0x1 | 0x2)) ==
>    0x2;
>}
># 520 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageKsm(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
> return ((unsigned long)page->mapping & (0x1 | 0x2)) ==
>    (0x1 | 0x2);
>}
>
>
>
>
>u64 stable_page_flags(struct page *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageUptodate(struct page *page)
>{
> int ret;
> page = ((typeof(page))_compound_head(page));
> ret = test_bit(PG_uptodate, &(page)->flags);
># 545 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
> if (ret)
>  __asm__ __volatile__("": : :"memory");
>
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageUptodate(struct page *page)
>{
> ((void)(sizeof(( long)(PageTail(page)))));
> __asm__ __volatile__("": : :"memory");
> __set_bit(PG_uptodate, &page->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageUptodate(struct page *page)
>{
> ((void)(sizeof(( long)(PageTail(page)))));
>
>
>
>
>
> __asm__ __volatile__("": : :"memory");
> set_bit(PG_uptodate, &page->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageUptodate(struct page *page) { clear_bit(PG_uptodate, &({ ((void)(sizeof(( long)(1 && PageTail(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(((typeof(page))_compound_head(page))))))); ((typeof(page))_compound_head(page)); }); })->flags); }
>
>int test_clear_page_writeback(struct page *page);
>int __test_set_page_writeback(struct page *page, bool keep_write);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_writeback(struct page *page)
>{
> __test_set_page_writeback(page, false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_writeback_keepwrite(struct page *page)
>{
> __test_set_page_writeback(page, true);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageHead(struct page *page) { return test_bit(PG_head, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageHead(struct page *page) { __set_bit(PG_head, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageHead(struct page *page) { __clear_bit(PG_head, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageHead(struct page *page) { clear_bit(PG_head, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void set_compound_head(struct page *page, struct page *head)
>{
> do { do { extern void __compiletime_assert_106(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->compound_head) == sizeof(char) || sizeof(page->compound_head) == sizeof(short) || sizeof(page->compound_head) == sizeof(int) || sizeof(page->compound_head) == sizeof(long)) || sizeof(page->compound_head) == sizeof(long long))) __compiletime_assert_106(); } while (0); do { *(volatile typeof(page->compound_head) *)&(page->compound_head) = ((unsigned long)head + 1); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void clear_compound_head(struct page *page)
>{
> do { do { extern void __compiletime_assert_107(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->compound_head) == sizeof(char) || sizeof(page->compound_head) == sizeof(short) || sizeof(page->compound_head) == sizeof(int) || sizeof(page->compound_head) == sizeof(long)) || sizeof(page->compound_head) == sizeof(long long))) __compiletime_assert_107(); } while (0); do { *(volatile typeof(page->compound_head) *)&(page->compound_head) = (0); } while (0); } while (0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ClearPageCompound(struct page *page)
>{
> do { if (__builtin_expect(!!(!PageHead(page)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"), "i" (605), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("108" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "108" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> ClearPageHead(page);
>}
>
>
>
>
>
>int PageHuge(struct page *page);
>int PageHeadHuge(struct page *page);
># 630 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageTransHuge(struct page *page)
>{
> ((void)(sizeof(( long)(PageTail(page)))));
> return PageHead(page);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageTransCompound(struct page *page)
>{
> return PageCompound(page);
>}
># 667 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageTransCompoundMap(struct page *page)
>{
> struct page *head;
>
> if (!PageTransCompound(page))
>  return 0;
>
> if (PageAnon(page))
>  return atomic_read(&page->_mapcount) < 0;
>
> head = ((typeof(page))_compound_head(page));
>
> return atomic_read(&page->_mapcount) ==
>        atomic_read(compound_mapcount_ptr(head));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageTransTail(struct page *page)
>{
> return PageTail(page);
>}
># 706 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageDoubleMap(struct page *page) { return test_bit(PG_double_map, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageDoubleMap(struct page *page) { set_bit(PG_double_map, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageDoubleMap(struct page *page) { clear_bit(PG_double_map, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPageDoubleMap(struct page *page) { return test_and_set_bit(PG_double_map, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageDoubleMap(struct page *page) { return test_and_clear_bit(PG_double_map, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); }
># 724 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageHasHWPoisoned(struct page *page) { return test_bit(PG_has_hwpoisoned, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void SetPageHasHWPoisoned(struct page *page) { set_bit(PG_has_hwpoisoned, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ClearPageHasHWPoisoned(struct page *page) { clear_bit(PG_has_hwpoisoned, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); }
> static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestSetPageHasHWPoisoned(struct page *page) { return test_and_set_bit(PG_has_hwpoisoned, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int TestClearPageHasHWPoisoned(struct page *page) { return test_and_clear_bit(PG_has_hwpoisoned, &({ ((void)(sizeof(( long)(!PageHead(page))))); ({ ((void)(sizeof(( long)(PagePoisoned(&page[1]))))); &page[1]; }); })->flags); }
># 736 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_page_hwpoison(struct page *page)
>{
> if (PageHWPoison(page))
>  return true;
> return PageHuge(page) && PageHWPoison(((typeof(page))_compound_head(page)));
>}
># 763 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_has_type(struct page *page)
>{
> return (int)page->page_type < -128;
>}
># 788 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageBuddy(struct page *page) { return ((page->page_type & (0xf0000000 | 0x00000080)) == 0xf0000000); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageBuddy(struct page *page) { ((void)(sizeof(( long)(!((page->page_type & (0xf0000000 | 0)) == 0xf0000000))))); page->page_type &= ~0x00000080; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageBuddy(struct page *page) { ((void)(sizeof(( long)(!PageBuddy(page))))); page->page_type |= 0x00000080; }
># 812 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageOffline(struct page *page) { return ((page->page_type & (0xf0000000 | 0x00000100)) == 0xf0000000); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageOffline(struct page *page) { ((void)(sizeof(( long)(!((page->page_type & (0xf0000000 | 0)) == 0xf0000000))))); page->page_type &= ~0x00000100; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageOffline(struct page *page) { ((void)(sizeof(( long)(!PageOffline(page))))); page->page_type |= 0x00000100; }
>
>extern void page_offline_freeze(void);
>extern void page_offline_thaw(void);
>extern void page_offline_begin(void);
>extern void page_offline_end(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageTable(struct page *page) { return ((page->page_type & (0xf0000000 | 0x00000200)) == 0xf0000000); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageTable(struct page *page) { ((void)(sizeof(( long)(!((page->page_type & (0xf0000000 | 0)) == 0xf0000000))))); page->page_type &= ~0x00000200; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageTable(struct page *page) { ((void)(sizeof(( long)(!PageTable(page))))); page->page_type |= 0x00000200; }
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageGuard(struct page *page) { return ((page->page_type & (0xf0000000 | 0x00000400)) == 0xf0000000); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageGuard(struct page *page) { ((void)(sizeof(( long)(!((page->page_type & (0xf0000000 | 0)) == 0xf0000000))))); page->page_type &= ~0x00000400; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageGuard(struct page *page) { ((void)(sizeof(( long)(!PageGuard(page))))); page->page_type |= 0x00000400; }
>
>extern bool is_free_buddy_page(struct page *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int PageIsolated(struct page *page) { return test_bit(PG_isolated, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __SetPageIsolated(struct page *page) { __set_bit(PG_isolated, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void __ClearPageIsolated(struct page *page) { __clear_bit(PG_isolated, &({ ((void)(sizeof(( long)(PagePoisoned(page))))); page; })->flags); };
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int PageSlabPfmemalloc(struct page *page)
>{
> ((void)(sizeof(( long)(!PageSlab(page)))));
> return PageActive(page);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __PageSlabPfmemalloc(struct page *page)
>{
> return PageActive(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void SetPageSlabPfmemalloc(struct page *page)
>{
> ((void)(sizeof(( long)(!PageSlab(page)))));
> SetPageActive(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __ClearPageSlabPfmemalloc(struct page *page)
>{
> ((void)(sizeof(( long)(!PageSlab(page)))));
> __ClearPageActive(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ClearPageSlabPfmemalloc(struct page *page)
>{
> ((void)(sizeof(( long)(!PageSlab(page)))));
> ClearPageActive(page);
>}
># 907 "/usr/src/linux-5.14.21-150500.53/include/linux/page-flags.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_has_private(struct page *page)
>{
> return !!(page->flags & (1UL << PG_private | 1UL << PG_private_2));
>}
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/local_lock.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/local_lock_internal.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/local_lock_internal.h"
>typedef struct {
>
>
>
>
>} local_lock_t;
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/local_lock.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
># 42 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>enum migratetype {
> MIGRATE_UNMOVABLE,
> MIGRATE_MOVABLE,
> MIGRATE_RECLAIMABLE,
> MIGRATE_PCPTYPES,
> MIGRATE_HIGHATOMIC = MIGRATE_PCPTYPES,
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> MIGRATE_CMA,
>
>
> MIGRATE_ISOLATE,
>
> MIGRATE_TYPES
>};
>
>
>extern const char * const migratetype_names[MIGRATE_TYPES];
># 81 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_migrate_movable(int mt)
>{
> return __builtin_expect(!!((mt) == MIGRATE_CMA), 0) || mt == MIGRATE_MOVABLE;
>}
>
>
>
>
>
>extern int page_group_by_mobility_disabled;
>
>
>
>
>
>
>struct free_area {
> struct list_head free_list[MIGRATE_TYPES];
> unsigned long nr_free;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *get_page_from_free_area(struct free_area *area,
>         int migratetype)
>{
> return ({ struct list_head *head__ = (&area->free_list[migratetype]); struct list_head *pos__ = ({ do { extern void __compiletime_assert_109(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(head__->next) == sizeof(char) || sizeof(head__->next) == sizeof(short) || sizeof(head__->next) == sizeof(int) || sizeof(head__->next) == sizeof(long)) || sizeof(head__->next) == sizeof(long long))) __compiletime_assert_109(); } while (0); (*(const volatile typeof( _Generic((head__->next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head__->next))) *)&(head__->next)); }); pos__ != head__ ? ({ void *__mptr = (void *)(pos__); do { extern void __compiletime_assert_110(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(pos__)), typeof(((struct page *)0)->lru)) && !__builtin_types_compatible_p(typeof(*(pos__)), typeof(void))))) __compiletime_assert_110(); } while (0); ((struct page *)(__mptr - __builtin_offsetof(struct page, lru))); }) : ((void *)0); })
>                      ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool free_area_empty(struct free_area *area, int migratetype)
>{
> return list_empty(&area->free_list[migratetype]);
>}
>
>struct pglist_data;
>
>
>
>
>
>
>
>struct zone_padding {
> char x[0];
>} __attribute__((__aligned__(1 << (6))));
>
>
>
>
>
>
>enum numa_stat_item {
> NUMA_HIT,
> NUMA_MISS,
> NUMA_FOREIGN,
> NUMA_INTERLEAVE_HIT,
> NUMA_LOCAL,
> NUMA_OTHER,
> NR_VM_NUMA_EVENT_ITEMS
>};
>
>
>
>
>enum zone_stat_item {
>
> NR_FREE_PAGES,
> NR_ZONE_LRU_BASE,
> NR_ZONE_INACTIVE_ANON = NR_ZONE_LRU_BASE,
> NR_ZONE_ACTIVE_ANON,
> NR_ZONE_INACTIVE_FILE,
> NR_ZONE_ACTIVE_FILE,
> NR_ZONE_UNEVICTABLE,
> NR_ZONE_WRITE_PENDING,
> NR_MLOCK,
>
> NR_BOUNCE,
>
> NR_ZSPAGES,
>
> NR_FREE_CMA_PAGES,
> NR_VM_ZONE_STAT_ITEMS };
>
>enum node_stat_item {
> NR_LRU_BASE,
> NR_INACTIVE_ANON = NR_LRU_BASE,
> NR_ACTIVE_ANON,
> NR_INACTIVE_FILE,
> NR_ACTIVE_FILE,
> NR_UNEVICTABLE,
> NR_SLAB_RECLAIMABLE_B,
> NR_SLAB_UNRECLAIMABLE_B,
> NR_ISOLATED_ANON,
> NR_ISOLATED_FILE,
> WORKINGSET_NODES,
> WORKINGSET_REFAULT_BASE,
> WORKINGSET_REFAULT_ANON = WORKINGSET_REFAULT_BASE,
> WORKINGSET_REFAULT_FILE,
> WORKINGSET_ACTIVATE_BASE,
> WORKINGSET_ACTIVATE_ANON = WORKINGSET_ACTIVATE_BASE,
> WORKINGSET_ACTIVATE_FILE,
> WORKINGSET_RESTORE_BASE,
> WORKINGSET_RESTORE_ANON = WORKINGSET_RESTORE_BASE,
> WORKINGSET_RESTORE_FILE,
> WORKINGSET_NODERECLAIM,
> NR_ANON_MAPPED,
> NR_FILE_MAPPED,
>
> NR_FILE_PAGES,
> NR_FILE_DIRTY,
> NR_WRITEBACK,
> NR_WRITEBACK_TEMP,
> NR_SHMEM,
> NR_SHMEM_THPS,
> NR_SHMEM_PMDMAPPED,
> NR_FILE_THPS,
> NR_FILE_PMDMAPPED,
> NR_ANON_THPS,
> NR_VMSCAN_WRITE,
> NR_VMSCAN_IMMEDIATE,
> NR_DIRTIED,
> NR_WRITTEN,
> NR_THROTTLED_WRITTEN,
> NR_KERNEL_MISC_RECLAIMABLE,
> NR_FOLL_PIN_ACQUIRED,
> NR_FOLL_PIN_RELEASED,
> NR_KERNEL_STACK_KB,
>
>
>
> NR_PAGETABLE,
>
> NR_SWAPCACHE,
>
>
> PGPROMOTE_SUCCESS,
>
> NR_VM_NODE_STAT_ITEMS
>};
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool vmstat_item_print_in_thp(enum node_stat_item item)
>{
> if (!1)
>  return false;
>
> return item == NR_ANON_THPS ||
>        item == NR_FILE_THPS ||
>        item == NR_SHMEM_THPS ||
>        item == NR_SHMEM_PMDMAPPED ||
>        item == NR_FILE_PMDMAPPED;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool vmstat_item_in_bytes(int idx)
>{
># 253 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> return (idx == NR_SLAB_RECLAIMABLE_B ||
>  idx == NR_SLAB_UNRECLAIMABLE_B);
>}
># 270 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>enum lru_list {
> LRU_INACTIVE_ANON = 0,
> LRU_ACTIVE_ANON = 0 + 1,
> LRU_INACTIVE_FILE = 0 + 2,
> LRU_ACTIVE_FILE = 0 + 2 + 1,
> LRU_UNEVICTABLE,
> NR_LRU_LISTS
>};
>
>enum vmscan_throttle_state {
> VMSCAN_THROTTLE_WRITEBACK,
> VMSCAN_THROTTLE_ISOLATED,
> VMSCAN_THROTTLE_NOPROGRESS,
> VMSCAN_THROTTLE_CONGESTED,
> NR_VMSCAN_THROTTLE,
>};
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_file_lru(enum lru_list lru)
>{
> return (lru == LRU_INACTIVE_FILE || lru == LRU_ACTIVE_FILE);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_active_lru(enum lru_list lru)
>{
> return (lru == LRU_ACTIVE_ANON || lru == LRU_ACTIVE_FILE);
>}
>
>
>
>enum lruvec_flags {
> LRUVEC_CONGESTED,
>
>
>};
>
>struct lruvec {
> struct list_head lists[NR_LRU_LISTS];
>
> spinlock_t lru_lock;
>
>
>
>
>
> unsigned long anon_cost;
> unsigned long file_cost;
>
> atomic_long_t nonresident_age;
>
> unsigned long refaults[2];
>
> unsigned long flags;
>
> struct pglist_data *pgdat;
>
>};
># 339 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>typedef unsigned isolate_mode_t;
>
>enum zone_watermarks {
> WMARK_MIN,
> WMARK_LOW,
> WMARK_HIGH,
> WMARK_PROMO,
> NR_WMARK
>};
># 373 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>struct per_cpu_pages {
> int count;
> int high;
> int batch;
> short free_factor;
>
> short expire;
>
>
>
> struct list_head lists[(MIGRATE_PCPTYPES * (3 + 1 + 1))];
>};
>
>struct per_cpu_zonestat {
>
> s8 vm_stat_diff[NR_VM_ZONE_STAT_ITEMS];
> s8 stat_threshold;
>
>
>
>
>
>
>
> unsigned long vm_numa_event[NR_VM_NUMA_EVENT_ITEMS];
>
>};
>
>struct per_cpu_nodestat {
> s8 stat_threshold;
> s8 vm_node_stat_diff[NR_VM_NODE_STAT_ITEMS];
>};
>
>
>
>enum zone_type {
># 420 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> ZONE_DMA,
>
>
> ZONE_DMA32,
>
>
>
>
>
>
> ZONE_NORMAL,
># 491 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> ZONE_MOVABLE,
>
> ZONE_DEVICE,
>
> __MAX_NR_ZONES
>
>};
>
>
>
>
>
>struct zone {
>
>
>
> unsigned long _watermark[NR_WMARK];
> unsigned long watermark_boost;
>
> unsigned long nr_reserved_highatomic;
># 521 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> long lowmem_reserve[5];
>
>
> int node;
>
> struct pglist_data *zone_pgdat;
> struct per_cpu_pages *per_cpu_pageset;
> struct per_cpu_zonestat *per_cpu_zonestats;
>
>
>
>
> int pageset_high;
> int pageset_batch;
># 545 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> unsigned long zone_start_pfn;
># 585 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> atomic_long_t managed_pages;
> unsigned long spanned_pages;
> unsigned long present_pages;
>
> unsigned long cma_pages;
>
>
> const char *name;
>
>
>
>
>
>
>
> unsigned long nr_isolate_pageblock;
>
>
>
>
> seqlock_t span_seqlock;
>
>
> int initialized;
>
>
> struct zone_padding _pad1_;
>
>
> struct free_area free_area[11];
>
>
> unsigned long flags;
>
>
> spinlock_t lock;
>
>
> struct zone_padding _pad2_;
>
>
>
>
>
>
> unsigned long percpu_drift_mark;
>
>
>
> unsigned long compact_cached_free_pfn;
>
> unsigned long compact_cached_migrate_pfn[2];
> unsigned long compact_init_migrate_pfn;
> unsigned long compact_init_free_pfn;
># 648 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> unsigned int compact_considered;
> unsigned int compact_defer_shift;
> int compact_order_failed;
>
>
>
>
> bool compact_blockskip_flush;
>
>
> bool contiguous;
>
> struct zone_padding _pad3_;
>
> atomic_long_t vm_stat[NR_VM_ZONE_STAT_ITEMS];
> atomic_long_t vm_numa_event[NR_VM_NUMA_EVENT_ITEMS];
> void *suse_kabi_padding;
>} __attribute__((__aligned__(1 << (6))));
>
>enum pgdat_flags {
> PGDAT_DIRTY,
>
>
>
> PGDAT_WRITEBACK,
>
>
> PGDAT_RECLAIM_LOCKED,
>};
>
>enum zone_flags {
> ZONE_BOOSTED_WATERMARK,
>
>
> ZONE_RECLAIM_ACTIVE,
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long zone_managed_pages(struct zone *zone)
>{
> return (unsigned long)atomic_long_read(&zone->managed_pages);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long zone_cma_pages(struct zone *zone)
>{
>
> return zone->cma_pages;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long zone_end_pfn(const struct zone *zone)
>{
> return zone->zone_start_pfn + zone->spanned_pages;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool zone_spans_pfn(const struct zone *zone, unsigned long pfn)
>{
> return zone->zone_start_pfn <= pfn && pfn < zone_end_pfn(zone);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool zone_is_initialized(struct zone *zone)
>{
> return zone->initialized;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool zone_is_empty(struct zone *zone)
>{
> return zone->spanned_pages == 0;
>}
># 763 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) enum zone_type page_zonenum(const struct page *page)
>{
> do { kcsan_set_access_mask(((1UL << 3) - 1) << (((((sizeof(unsigned long)*8) - 0) - 10) - 3) * (3 != 0))); __kcsan_check_access(&(page->flags), sizeof(page->flags), (1 << 3)); kcsan_set_access_mask(0); kcsan_atomic_next(1); } while (0);
> return (page->flags >> (((((sizeof(unsigned long)*8) - 0) - 10) - 3) * (3 != 0))) & ((1UL << 3) - 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_zone_device_page(const struct page *page)
>{
> return page_zonenum(page) == ZONE_DEVICE;
>}
>extern void memmap_init_zone_device(struct zone *, unsigned long,
>        unsigned long, struct dev_pagemap *);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_zone_movable_page(const struct page *page)
>{
> return page_zonenum(page) == ZONE_MOVABLE;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool zone_intersects(struct zone *zone,
>  unsigned long start_pfn, unsigned long nr_pages)
>{
> if (zone_is_empty(zone))
>  return false;
> if (start_pfn >= zone_end_pfn(zone) ||
>     start_pfn + nr_pages <= zone->zone_start_pfn)
>  return false;
>
> return true;
>}
># 815 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>enum {
> ZONELIST_FALLBACK,
>
>
>
>
>
> ZONELIST_NOFALLBACK,
>
> MAX_ZONELISTS
>};
>
>
>
>
>
>struct zoneref {
> struct zone *zone;
> int zone_idx;
>};
># 850 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>struct zonelist {
> struct zoneref _zonerefs[((1 << 10) * 5) + 1];
>};
>
>
>
>
>
>
>extern struct page *mem_map;
>
>
>struct deferred_split {
> spinlock_t split_queue_lock;
> struct list_head split_queue;
> unsigned long split_queue_len;
>};
># 877 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>typedef struct pglist_data {
>
>
>
>
>
> struct zone node_zones[5];
>
>
>
>
>
>
> struct zonelist node_zonelists[MAX_ZONELISTS];
>
> int nr_zones;
># 912 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> spinlock_t node_size_lock;
>
> unsigned long node_start_pfn;
> unsigned long node_present_pages;
> unsigned long node_spanned_pages;
>
> int node_id;
> wait_queue_head_t kswapd_wait;
> wait_queue_head_t pfmemalloc_wait;
>
>
> wait_queue_head_t reclaim_wait[NR_VMSCAN_THROTTLE];
>
> atomic_t nr_writeback_throttled;
> unsigned long nr_reclaim_start;
>
> struct task_struct *kswapd;
>
> int kswapd_order;
> enum zone_type kswapd_highest_zoneidx;
>
> int kswapd_failures;
>
>
> int kcompactd_max_order;
> enum zone_type kcompactd_highest_zoneidx;
> wait_queue_head_t kcompactd_wait;
> struct task_struct *kcompactd;
> bool proactive_compact_trigger;
>
>
>
>
>
> unsigned long totalreserve_pages;
>
>
>
>
>
> unsigned long min_unmapped_pages;
> unsigned long min_slab_pages;
>
>
>
> struct zone_padding _pad1_;
>
>
>
>
>
>
> unsigned long first_deferred_pfn;
>
>
>
> struct deferred_split deferred_split_queue;
># 978 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> struct lruvec __lruvec;
>
> unsigned long flags;
>
> struct zone_padding _pad2_;
>
>
> struct per_cpu_nodestat *per_cpu_nodestats;
> atomic_long_t vm_stat[NR_VM_NODE_STAT_ITEMS];
>
> struct memory_tier *memtier;
>
>} pg_data_t;
># 1004 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pgdat_end_pfn(pg_data_t *pgdat)
>{
> return pgdat->node_start_pfn + pgdat->node_spanned_pages;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pgdat_is_empty(pg_data_t *pgdat)
>{
> return !pgdat->node_start_pfn && !pgdat->node_spanned_pages;
>}
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h" 2
>
>
>
>
>struct page;
>struct zone;
>struct pglist_data;
>struct mem_section;
>struct memory_block;
>struct resource;
>struct vmem_altmap;
># 51 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>extern pg_data_t *node_data[];
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_refresh_nodedata(int nid, pg_data_t *pgdat)
>{
> node_data[nid] = pgdat;
>}
># 75 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>struct page *pfn_to_online_page(unsigned long pfn);
>
>
>enum {
>
> MMOP_OFFLINE = 0,
>
> MMOP_ONLINE,
>
> MMOP_ONLINE_KERNEL,
>
> MMOP_ONLINE_MOVABLE,
>};
>
>
>typedef int mhp_t;
># 116 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>struct mhp_params {
> struct vmem_altmap *altmap;
> pgprot_t pgprot;
>};
>
>bool mhp_range_allowed(u64 start, u64 size, bool need_mapping);
>struct range mhp_get_pluggable_range(bool need_mapping);
># 131 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned zone_span_seqbegin(struct zone *zone)
>{
> return read_seqbegin(&zone->span_seqlock);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int zone_span_seqretry(struct zone *zone, unsigned iv)
>{
> return read_seqretry(&zone->span_seqlock, iv);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zone_span_writelock(struct zone *zone)
>{
> write_seqlock(&zone->span_seqlock);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zone_span_writeunlock(struct zone *zone)
>{
> write_sequnlock(&zone->span_seqlock);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zone_seqlock_init(struct zone *zone)
>{
> do { do { spinlock_check(&(&zone->span_seqlock)->lock); *(&(&zone->span_seqlock)->lock) = (spinlock_t) { { .rlock = { .raw_lock = { { .val = { (0) } } }, } } }; } while (0); do { seqcount_spinlock_t *____s = (&(&zone->span_seqlock)->seqcount); __seqcount_init(&____s->seqcount, ((void *)0), ((void *)0)); ; } while (0); } while (0);
>}
>extern int zone_grow_free_lists(struct zone *zone, unsigned long new_nr_pages);
>extern int zone_grow_waitqueues(struct zone *zone, unsigned long nr_pages);
>extern int add_one_highpage(struct page *page, int pfn, int bad_ppro);
>extern void adjust_present_page_count(struct zone *zone, long nr_pages);
>
>extern int mhp_init_memmap_on_memory(unsigned long pfn, unsigned long nr_pages,
>         struct zone *zone);
>extern void mhp_deinit_memmap_on_memory(unsigned long pfn, unsigned long nr_pages);
>extern int online_pages(unsigned long pfn, unsigned long nr_pages,
>   struct zone *zone);
>extern struct zone *test_pages_in_a_zone(unsigned long start_pfn,
>      unsigned long end_pfn);
>extern void __offline_isolated_pages(unsigned long start_pfn,
>         unsigned long end_pfn);
>
>typedef void (*online_page_callback_t)(struct page *page, unsigned int order);
>
>extern void generic_online_page(struct page *page, unsigned int order);
>extern int set_online_page_callback(online_page_callback_t callback);
>extern int restore_online_page_callback(online_page_callback_t callback);
>
>extern int try_online_node(int nid);
>
>extern int arch_add_memory(int nid, u64 start, u64 size,
>      struct mhp_params *params);
>extern u64 max_mem_size;
>
>extern int mhp_online_type_from_str(const char *str);
>
>
>extern int mhp_default_online_type;
>
>extern bool movable_node_enabled;
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool movable_node_is_enabled(void)
>{
> return movable_node_enabled;
>}
>
>extern void arch_remove_memory(u64 start, u64 size, struct vmem_altmap *altmap);
>extern void __remove_pages(unsigned long start_pfn, unsigned long nr_pages,
>      struct vmem_altmap *altmap);
>
>
>extern int __add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
>         struct mhp_params *params);
># 204 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>int add_pages(int nid, unsigned long start_pfn, unsigned long nr_pages,
>       struct mhp_params *params);
>
>
>void get_online_mems(void);
>void put_online_mems(void);
>
>void mem_hotplug_begin(void);
>void mem_hotplug_done(void);
># 257 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>struct range arch_get_mappable_range(void);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void pgdat_resize_lock(struct pglist_data *pgdat, unsigned long *flags)
>{
> do { do { ({ unsigned long __dummy; typeof(*flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); *flags = _raw_spin_lock_irqsave(spinlock_check(&pgdat->node_size_lock)); } while (0); } while (0);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void pgdat_resize_unlock(struct pglist_data *pgdat, unsigned long *flags)
>{
> spin_unlock_irqrestore(&pgdat->node_size_lock, *flags);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void pgdat_resize_init(struct pglist_data *pgdat)
>{
> do { spinlock_check(&pgdat->node_size_lock); *(&pgdat->node_size_lock) = (spinlock_t) { { .rlock = { .raw_lock = { { .val = { (0) } } }, } } }; } while (0);
>}
># 289 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>extern void try_offline_node(int nid);
>extern int offline_pages(unsigned long start_pfn, unsigned long nr_pages);
>extern int remove_memory(u64 start, u64 size);
>extern void __remove_memory(u64 start, u64 size);
>extern int offline_and_remove_memory(u64 start, u64 size);
># 311 "/usr/src/linux-5.14.21-150500.53/include/linux/memory_hotplug.h"
>extern void set_zone_contiguous(struct zone *zone);
>extern void clear_zone_contiguous(struct zone *zone);
>
>
>extern void __attribute__((__section__(".ref.text"))) __attribute__((__noinline__)) free_area_init_core_hotplug(struct pglist_data *pgdat);
>extern int __add_memory(int nid, u64 start, u64 size, mhp_t mhp_flags);
>extern int add_memory(int nid, u64 start, u64 size, mhp_t mhp_flags);
>extern int add_memory_resource(int nid, struct resource *resource,
>          mhp_t mhp_flags);
>extern int add_memory_driver_managed(int nid, u64 start, u64 size,
>         const char *resource_name,
>         mhp_t mhp_flags);
>extern void move_pfn_range_to_zone(struct zone *zone, unsigned long start_pfn,
>       unsigned long nr_pages,
>       struct vmem_altmap *altmap, int migratetype);
>extern void remove_pfn_range_from_zone(struct zone *zone,
>           unsigned long start_pfn,
>           unsigned long nr_pages);
>extern bool is_memblock_offlined(struct memory_block *mem);
>extern int sparse_add_section(int nid, unsigned long pfn,
>  unsigned long nr_pages, struct vmem_altmap *altmap);
>extern void sparse_remove_section(struct mem_section *ms,
>  unsigned long pfn, unsigned long nr_pages,
>  unsigned long map_offset, struct vmem_altmap *altmap);
>extern struct page *sparse_decode_mem_map(unsigned long coded_mem_map,
>       unsigned long pnum);
>extern struct zone *zone_for_pfn_range(int online_type, int nid,
>  unsigned long start_pfn, unsigned long nr_pages);
>extern int arch_create_linear_mapping(int nid, u64 start, u64 size,
>          struct mhp_params *params);
>void arch_remove_linear_mapping(u64 start, u64 size);
>extern bool mhp_supports_memmap_on_memory(unsigned long size);
># 1015 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
>
>void build_all_zonelists(pg_data_t *pgdat);
>void wakeup_kswapd(struct zone *zone, gfp_t gfp_mask, int order,
>     enum zone_type highest_zoneidx);
>bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
>    int highest_zoneidx, unsigned int alloc_flags,
>    long free_pages);
>bool zone_watermark_ok(struct zone *z, unsigned int order,
>  unsigned long mark, int highest_zoneidx,
>  unsigned int alloc_flags);
>bool zone_watermark_ok_safe(struct zone *z, unsigned int order,
>  unsigned long mark, int highest_zoneidx);
>
>
>
>
>enum meminit_context {
> MEMINIT_EARLY,
> MEMINIT_HOTPLUG,
>};
>
>extern void init_currently_empty_zone(struct zone *zone, unsigned long start_pfn,
>         unsigned long size);
>
>extern void lruvec_init(struct lruvec *lruvec);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pglist_data *lruvec_pgdat(struct lruvec *lruvec)
>{
>
> return lruvec->pgdat;
>
>
>
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int local_memory_node(int node_id) { return node_id; };
># 1062 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool zone_is_zone_device(struct zone *zone)
>{
> return ((zone) - (zone)->zone_pgdat->node_zones) == ZONE_DEVICE;
>}
># 1079 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool managed_zone(struct zone *zone)
>{
> return zone_managed_pages(zone);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool populated_zone(struct zone *zone)
>{
> return zone->present_pages;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int zone_to_nid(struct zone *zone)
>{
> return zone->node;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zone_set_nid(struct zone *zone, int nid)
>{
> zone->node = nid;
>}
># 1109 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>extern int movable_zone;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_highmem_idx(enum zone_type idx)
>{
>
>
>
>
> return 0;
>
>}
>
>
>bool has_managed_dma(void);
># 1137 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_highmem(struct zone *zone)
>{
>
>
>
> return 0;
>
>}
>
>
>struct ctl_table;
>
>int min_free_kbytes_sysctl_handler(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>int watermark_scale_factor_sysctl_handler(struct ctl_table *, int, void *,
>  size_t *, loff_t *);
>extern int sysctl_lowmem_reserve_ratio[5];
>int lowmem_reserve_ratio_sysctl_handler(struct ctl_table *, int, void *,
>  size_t *, loff_t *);
>int percpu_pagelist_high_fraction_sysctl_handler(struct ctl_table *, int,
>  void *, size_t *, loff_t *);
>int sysctl_min_unmapped_ratio_sysctl_handler(struct ctl_table *, int,
>  void *, size_t *, loff_t *);
>int sysctl_min_slab_ratio_sysctl_handler(struct ctl_table *, int,
>  void *, size_t *, loff_t *);
>int numa_zonelist_order_handler(struct ctl_table *, int,
>  void *, size_t *, loff_t *);
>extern int percpu_pagelist_high_fraction;
>extern char numa_zonelist_order[];
># 1179 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmzone.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmzone_64.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmzone_64.h"
>extern struct pglist_data *node_data[];
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mmzone.h" 2
># 1180 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h" 2
>
>
>
>extern struct pglist_data *first_online_pgdat(void);
>extern struct pglist_data *next_online_pgdat(struct pglist_data *pgdat);
>extern struct zone *next_zone(struct zone *zone);
># 1215 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct zone *zonelist_zone(struct zoneref *zoneref)
>{
> return zoneref->zone;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int zonelist_zone_idx(struct zoneref *zoneref)
>{
> return zoneref->zone_idx;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int zonelist_node_idx(struct zoneref *zoneref)
>{
> return zone_to_nid(zoneref->zone);
>}
>
>struct zoneref *__next_zones_zonelist(struct zoneref *z,
>     enum zone_type highest_zoneidx,
>     nodemask_t *nodes);
># 1249 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct zoneref *next_zones_zonelist(struct zoneref *z,
>     enum zone_type highest_zoneidx,
>     nodemask_t *nodes)
>{
> if (__builtin_expect(!!(!nodes && zonelist_zone_idx(z) <= highest_zoneidx), 1))
>  return z;
> return __next_zones_zonelist(z, highest_zoneidx, nodes);
>}
># 1275 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct zoneref *first_zones_zonelist(struct zonelist *zonelist,
>     enum zone_type highest_zoneidx,
>     nodemask_t *nodes)
>{
> return next_zones_zonelist(zonelist->_zonerefs,
>       highest_zoneidx, nodes);
>}
># 1320 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool movable_only_nodes(nodemask_t *nodes)
>{
> struct zonelist *zonelist;
> struct zoneref *z;
> int nid;
>
> if (__nodes_empty(&(*nodes), (1 << 10)))
>  return false;
>
>
>
>
>
>
> nid = __first_node(&(*nodes));
> zonelist = &(node_data[nid])->node_zonelists[ZONELIST_FALLBACK];
> z = first_zones_zonelist(zonelist, ZONE_NORMAL, nodes);
> return (!z->zone) ? true : false;
>}
># 1370 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pfn_to_section_nr(unsigned long pfn)
>{
> return pfn >> (27 - 12);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long section_nr_to_pfn(unsigned long sec)
>{
> return sec << (27 - 12);
>}
># 1398 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>struct mem_section_usage {
>
> unsigned long subsection_map[((((1UL << (27 - 21))) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];
>
>
> unsigned long pageblock_flags[0];
>};
>
>void subsection_map_init(unsigned long pfn, unsigned long nr_pages);
>
>struct page;
>struct page_ext;
>struct mem_section {
># 1423 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
> unsigned long section_mem_map;
>
> struct mem_section_usage *usage;
>
>
>
>
>
> struct page_ext *page_ext;
> unsigned long pad;
>
>
>
>
>
>};
># 1451 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>extern struct mem_section **mem_section;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long *section_to_usemap(struct mem_section *ms)
>{
> return ms->usage->pageblock_flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_section *__nr_to_section(unsigned long nr)
>{
>
> if (!mem_section)
>  return ((void *)0);
>
> if (!mem_section[((nr) / (((1UL) << 12) / sizeof (struct mem_section)))])
>  return ((void *)0);
> return &mem_section[((nr) / (((1UL) << 12) / sizeof (struct mem_section)))][nr & ((((1UL) << 12) / sizeof (struct mem_section)) - 1)];
>}
>extern size_t mem_section_usage_size(void);
># 1495 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *__section_mem_map_addr(struct mem_section *section)
>{
> unsigned long map = section->section_mem_map;
> map &= (~((1UL<<5)-1));
> return (struct page *)map;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int present_section(struct mem_section *section)
>{
> return (section && (section->section_mem_map & (1UL<<0)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int present_section_nr(unsigned long nr)
>{
> return present_section(__nr_to_section(nr));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int valid_section(struct mem_section *section)
>{
> return (section && (section->section_mem_map & (1UL<<1)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int early_section(struct mem_section *section)
>{
> return (section && (section->section_mem_map & (1UL<<3)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int valid_section_nr(unsigned long nr)
>{
> return valid_section(__nr_to_section(nr));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int online_section(struct mem_section *section)
>{
> return (section && (section->section_mem_map & (1UL<<2)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int online_device_section(struct mem_section *section)
>{
> unsigned long flags = (1UL<<2) | (1UL<<4);
>
> return section && ((section->section_mem_map & flags) == flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int online_section_nr(unsigned long nr)
>{
> return online_section(__nr_to_section(nr));
>}
>
>
>void online_mem_sections(unsigned long start_pfn, unsigned long end_pfn);
>void offline_mem_sections(unsigned long start_pfn, unsigned long end_pfn);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_section *__pfn_to_section(unsigned long pfn)
>{
> return __nr_to_section(pfn_to_section_nr(pfn));
>}
>
>extern unsigned long __highest_present_section_nr;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int subsection_map_index(unsigned long pfn)
>{
> return (pfn & ~((~((1UL << (27 - 12))-1)))) / (1UL << (21 - 12));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pfn_section_valid(struct mem_section *ms, unsigned long pfn)
>{
> int idx = subsection_map_index(pfn);
>
> return test_bit(idx, ms->usage->subsection_map);
>}
># 1587 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pfn_valid(unsigned long pfn)
>{
> struct mem_section *ms;
>
>
>
>
>
>
>
> if (((unsigned long)((((phys_addr_t)(pfn) << 12)) >> 12)) != pfn)
>  return 0;
>
> if (pfn_to_section_nr(pfn) >= (1UL << (((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )) ? 52 : 46) - 27)))
>  return 0;
> ms = __nr_to_section(pfn_to_section_nr(pfn));
> if (!valid_section(ms))
>  return 0;
>
>
>
>
> return early_section(ms) || pfn_section_valid(ms, pfn);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pfn_in_present_section(unsigned long pfn)
>{
> if (pfn_to_section_nr(pfn) >= (1UL << (((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )) ? 52 : 46) - 27)))
>  return 0;
> return present_section(__nr_to_section(pfn_to_section_nr(pfn)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long next_present_section_nr(unsigned long section_nr)
>{
> while (++section_nr <= __highest_present_section_nr) {
>  if (present_section_nr(section_nr))
>   return section_nr;
> }
>
> return -1;
>}
># 1645 "/usr/src/linux-5.14.21-150500.53/include/linux/mmzone.h"
>void sparse_init(void);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h" 1
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/arch_topology.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/arch_topology.h"
>void topology_normalize_cpu_scale(void);
>int topology_update_cpu_topology(void);
>
>struct device_node;
>bool topology_parse_cpu_capacity(struct device_node *cpu_node, int cpu);
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_cpu_scale; extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) cpu_scale;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long topology_get_cpu_scale(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(cpu_scale)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(cpu_scale)))) *)((&(cpu_scale))))); (typeof((typeof(*((&(cpu_scale)))) *)((&(cpu_scale))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>void topology_set_cpu_scale(unsigned int cpu, unsigned long capacity);
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_arch_freq_scale; extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) arch_freq_scale;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long topology_get_freq_scale(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(arch_freq_scale)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(arch_freq_scale)))) *)((&(arch_freq_scale))))); (typeof((typeof(*((&(arch_freq_scale)))) *)((&(arch_freq_scale))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>void topology_set_freq_scale(const struct cpumask *cpus, unsigned long cur_freq,
>        unsigned long max_freq);
>bool topology_scale_freq_invariant(void);
>
>enum scale_freq_source {
> SCALE_FREQ_SOURCE_CPUFREQ = 0,
> SCALE_FREQ_SOURCE_ARCH,
> SCALE_FREQ_SOURCE_CPPC,
>};
>
>struct scale_freq_data {
> enum scale_freq_source source;
> void (*set_freq_scale)(void);
>};
>
>void topology_scale_freq_tick(void);
>void topology_set_scale_freq_source(struct scale_freq_data *data, const struct cpumask *cpus);
>void topology_clear_scale_freq_source(enum scale_freq_source source, const struct cpumask *cpus);
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_thermal_pressure; extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) thermal_pressure;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long topology_get_thermal_pressure(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(thermal_pressure)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(thermal_pressure)))) *)((&(thermal_pressure))))); (typeof((typeof(*((&(thermal_pressure)))) *)((&(thermal_pressure))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>void topology_set_thermal_pressure(const struct cpumask *cpus,
>       unsigned long th_pressure);
>
>struct cpu_topology {
> int thread_id;
> int core_id;
> int cluster_id;
> int package_id;
> int llc_id;
> cpumask_t thread_sibling;
> cpumask_t core_sibling;
> cpumask_t cluster_sibling;
> cpumask_t llc_sibling;
>};
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h" 1
># 38 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec_def.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec_def.h"
>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 mpc_table {
> char signature[4];
> unsigned short length;
> char spec;
> char checksum;
> char oem[8];
> char productid[12];
> unsigned int oemptr;
> unsigned short oemsize;
> unsigned short oemcount;
> unsigned int lapic;
> unsigned int reserved;
>};
># 68 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec_def.h"
>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_bus {
> unsigned char type;
> unsigned char busid;
> unsigned char bustype[6];
>};
># 106 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec_def.h"
>struct mpc_ioapic {
> unsigned char type;
> unsigned char apicid;
> unsigned char apicver;
> unsigned char flags;
> unsigned int apicaddr;
>};
>
>struct mpc_intsrc {
> unsigned char type;
> unsigned char irqtype;
> unsigned short irqflag;
> unsigned char srcbus;
> unsigned char srcbusirq;
> unsigned char dstapic;
> unsigned char dstirq;
>};
>
>enum mp_irq_source_types {
> mp_INT = 0,
> mp_NMI = 1,
> mp_SMI = 2,
> mp_ExtINT = 3
>};
># 145 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec_def.h"
>struct mpc_lintsrc {
> unsigned char type;
> unsigned char irqtype;
> unsigned short irqflag;
> unsigned char srcbusid;
> unsigned char srcbusirq;
> unsigned char destapic;
> unsigned char destapiclint;
>};
>
>
>
>struct mpc_oemtable {
> char signature[4];
> unsigned short length;
> char rev;
> char checksum;
> char mpc[8];
>};
># 177 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec_def.h"
>enum mp_bustype {
> MP_BUS_ISA = 1,
> MP_BUS_EISA,
> MP_BUS_PCI,
>};
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h" 1
>
>
>
>
>
>
>struct ghcb;
>struct mpc_bus;
>struct mpc_cpu;
>struct pt_regs;
>struct mpc_table;
>struct cpuinfo_x86;
>struct irq_domain;
>
>
>
>
>
>
>
>struct x86_init_mpparse {
> void (*setup_ioapic_ids)(void);
> void (*find_smp_config)(void);
> void (*get_smp_config)(unsigned int early);
>};
># 35 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_init_resources {
> void (*probe_roms)(void);
> void (*reserve_resources)(void);
> char *(*memory_setup)(void);
>};
># 50 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_init_irqs {
> void (*pre_vector_init)(void);
> void (*intr_init)(void);
> void (*intr_mode_select)(void);
> void (*intr_mode_init)(void);
> struct irq_domain *(*create_pci_msi_domain)(void);
>};
>
>
>
>
>
>
>struct x86_init_oem {
> void (*arch_setup)(void);
> void (*banner)(void);
>};
># 75 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_init_paging {
> void (*pagetable_init)(void);
>};
># 86 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_init_timers {
> void (*setup_percpu_clockev)(void);
> void (*timer_init)(void);
> void (*wallclock_init)(void);
>};
>
>
>
>
>
>struct x86_init_iommu {
> int (*iommu_init)(void);
>};
># 107 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_init_pci {
> int (*arch_init)(void);
> int (*init)(void);
> void (*init_irq)(void);
> void (*fixup_irqs)(void);
>};
># 123 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_hyper_init {
> void (*init_platform)(void);
> void (*guest_late_init)(void);
> bool (*x2apic_available)(void);
> bool (*msi_ext_dest_id)(void);
> void (*init_mem_mapping)(void);
> void (*init_after_bootmem)(void);
>};
>
>
>
>
>
>
>
>struct x86_init_acpi {
> void (*set_root_pointer)(u64 addr);
> u64 (*get_root_pointer)(void);
> void (*reduced_hw_early_init)(void);
>};
># 152 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_guest {
> void (*enc_status_change_prepare)(unsigned long vaddr, int npages, bool enc);
> bool (*enc_status_change_finish)(unsigned long vaddr, int npages, bool enc);
> bool (*enc_tlb_flush_required)(bool enc);
> bool (*enc_cache_flush_required)(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_hyper_init hyper;
> struct x86_init_acpi acpi;
>};
>
>
>
>
>
>
>struct x86_cpuinit_ops {
> void (*setup_percpu_clockev)(void);
> void (*early_percpu_clock_init)(void);
> void (*fixup_cpu_id)(struct cpuinfo_x86 *c, int node);
>};
>
>struct timespec64;
># 208 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_legacy_devices {
> int pnpbios;
>};
># 221 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>enum x86_legacy_i8042_state {
> X86_LEGACY_I8042_PLATFORM_ABSENT,
> X86_LEGACY_I8042_FIRMWARE_ABSENT,
> X86_LEGACY_I8042_EXPECTED_PRESENT,
>};
># 239 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_legacy_features {
> enum x86_legacy_i8042_state i8042;
> int rtc;
> int warm_reset;
> int no_vga;
> int reserve_bios_regions;
> struct x86_legacy_devices devices;
>};
># 263 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_hyper_runtime {
> void (*pin_vcpu)(int cpu);
> void (*sev_es_hcall_prepare)(struct ghcb *ghcb, struct pt_regs *regs);
> bool (*sev_es_hcall_finish)(struct ghcb *ghcb, struct pt_regs *regs);
>};
># 290 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/x86_init.h"
>struct x86_platform_ops {
> unsigned long (*calibrate_cpu)(void);
> unsigned long (*calibrate_tsc)(void);
> void (*get_wallclock)(struct timespec64 *ts);
> int (*set_wallclock)(const struct timespec64 *ts);
> void (*iommu_shutdown)(void);
> bool (*is_untracked_pat_range)(u64 start, u64 end);
> void (*nmi_init)(void);
> unsigned char (*get_nmi_reason)(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_hyper_runtime hyper;
> struct x86_guest guest;
>};
>
>struct pci_dev;
>
>struct x86_msi_ops {
> void (*restore_msi_irqs)(struct pci_dev *dev);
>};
>
>struct x86_apic_ops {
> unsigned int (*io_apic_read) (unsigned int apic, unsigned int reg);
> void (*restore)(void);
>};
>
>extern struct x86_init_ops x86_init;
>extern struct x86_cpuinit_ops x86_cpuinit;
>extern struct x86_platform_ops x86_platform;
>extern struct x86_msi_ops x86_msi;
>extern struct x86_apic_ops x86_apic_ops;
>
>extern void x86_early_init_platform_quirks(void);
>extern void x86_init_noop(void);
>extern void x86_init_uint_noop(unsigned int unused);
>extern bool bool_x86_init_noop(void);
>extern void x86_op_int_noop(int cpu);
>extern bool x86_pnpbios_disabled(void);
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/apicdef.h" 1
># 179 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/apicdef.h"
>struct local_apic {
>
>        struct { unsigned int __reserved[4]; } __reserved_01;
>
>        struct { unsigned int __reserved[4]; } __reserved_02;
>
>        struct {
>  unsigned int __reserved_1 : 24,
>   phys_apic_id : 4,
>   __reserved_2 : 4;
>  unsigned int __reserved[3];
> } id;
>
>        const
> struct {
>  unsigned int version : 8,
>   __reserved_1 : 8,
>   max_lvt : 8,
>   __reserved_2 : 8;
>  unsigned int __reserved[3];
> } version;
>
>        struct { unsigned int __reserved[4]; } __reserved_03;
>
>        struct { unsigned int __reserved[4]; } __reserved_04;
>
>        struct { unsigned int __reserved[4]; } __reserved_05;
>
>        struct { unsigned int __reserved[4]; } __reserved_06;
>
>        struct {
>  unsigned int priority : 8,
>   __reserved_1 : 24;
>  unsigned int __reserved_2[3];
> } tpr;
>
>        const
> struct {
>  unsigned int priority : 8,
>   __reserved_1 : 24;
>  unsigned int __reserved_2[3];
> } apr;
>
>        const
> struct {
>  unsigned int priority : 8,
>   __reserved_1 : 24;
>  unsigned int __reserved_2[3];
> } ppr;
>
>        struct {
>  unsigned int eoi;
>  unsigned int __reserved[3];
> } eoi;
>
>        struct { unsigned int __reserved[4]; } __reserved_07;
>
>        struct {
>  unsigned int __reserved_1 : 24,
>   logical_dest : 8;
>  unsigned int __reserved_2[3];
> } ldr;
>
>        struct {
>  unsigned int __reserved_1 : 28,
>   model : 4;
>  unsigned int __reserved_2[3];
> } dfr;
>
>        struct {
>  unsigned int spurious_vector : 8,
>   apic_enabled : 1,
>   focus_cpu : 1,
>   __reserved_2 : 22;
>  unsigned int __reserved_3[3];
> } svr;
>
>        struct {
>         unsigned int bitfield;
>  unsigned int __reserved[3];
> } isr [8];
>
>        struct {
>         unsigned int bitfield;
>  unsigned int __reserved[3];
> } tmr [8];
>
>        struct {
>         unsigned int bitfield;
>  unsigned int __reserved[3];
> } irr [8];
>
>        union {
>  struct {
>   unsigned int send_cs_error : 1,
>    receive_cs_error : 1,
>    send_accept_error : 1,
>    receive_accept_error : 1,
>    __reserved_1 : 1,
>    send_illegal_vector : 1,
>    receive_illegal_vector : 1,
>    illegal_register_address : 1,
>    __reserved_2 : 24;
>   unsigned int __reserved_3[3];
>  } error_bits;
>  struct {
>   unsigned int errors;
>   unsigned int __reserved_3[3];
>  } all_errors;
> } esr;
>
>        struct { unsigned int __reserved[4]; } __reserved_08;
>
>        struct { unsigned int __reserved[4]; } __reserved_09;
>
>        struct { unsigned int __reserved[4]; } __reserved_10;
>
>        struct { unsigned int __reserved[4]; } __reserved_11;
>
>        struct { unsigned int __reserved[4]; } __reserved_12;
>
>        struct { unsigned int __reserved[4]; } __reserved_13;
>
>        struct { unsigned int __reserved[4]; } __reserved_14;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   destination_mode : 1,
>   delivery_status : 1,
>   __reserved_1 : 1,
>   level : 1,
>   trigger : 1,
>   __reserved_2 : 2,
>   shorthand : 2,
>   __reserved_3 : 12;
>  unsigned int __reserved_4[3];
> } icr1;
>
>        struct {
>  union {
>   unsigned int __reserved_1 : 24,
>    phys_dest : 4,
>    __reserved_2 : 4;
>   unsigned int __reserved_3 : 24,
>    logical_dest : 8;
>  } dest;
>  unsigned int __reserved_4[3];
> } icr2;
>
>        struct {
>  unsigned int vector : 8,
>   __reserved_1 : 4,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   timer_mode : 1,
>   __reserved_3 : 14;
>  unsigned int __reserved_4[3];
> } lvt_timer;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   __reserved_3 : 15;
>  unsigned int __reserved_4[3];
> } lvt_thermal;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   __reserved_3 : 15;
>  unsigned int __reserved_4[3];
> } lvt_pc;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   polarity : 1,
>   remote_irr : 1,
>   trigger : 1,
>   mask : 1,
>   __reserved_2 : 15;
>  unsigned int __reserved_3[3];
> } lvt_lint0;
>
>        struct {
>  unsigned int vector : 8,
>   delivery_mode : 3,
>   __reserved_1 : 1,
>   delivery_status : 1,
>   polarity : 1,
>   remote_irr : 1,
>   trigger : 1,
>   mask : 1,
>   __reserved_2 : 15;
>  unsigned int __reserved_3[3];
> } lvt_lint1;
>
>        struct {
>  unsigned int vector : 8,
>   __reserved_1 : 4,
>   delivery_status : 1,
>   __reserved_2 : 3,
>   mask : 1,
>   __reserved_3 : 15;
>  unsigned int __reserved_4[3];
> } lvt_error;
>
>        struct {
>  unsigned int initial_count;
>  unsigned int __reserved_2[3];
> } timer_icr;
>
>        const
> struct {
>  unsigned int curr_count;
>  unsigned int __reserved_2[3];
> } timer_ccr;
>
>        struct { unsigned int __reserved[4]; } __reserved_16;
>
>        struct { unsigned int __reserved[4]; } __reserved_17;
>
>        struct { unsigned int __reserved[4]; } __reserved_18;
>
>        struct { unsigned int __reserved[4]; } __reserved_19;
>
>        struct {
>  unsigned int divisor : 4,
>   __reserved_1 : 28;
>  unsigned int __reserved_2[3];
> } timer_dcr;
>
>        struct { unsigned int __reserved[4]; } __reserved_20;
>
>} __attribute__ ((packed));
># 435 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/apicdef.h"
>enum apic_delivery_modes {
> APIC_DELIVERY_MODE_FIXED = 0,
> APIC_DELIVERY_MODE_LOWESTPRIO = 1,
> APIC_DELIVERY_MODE_SMI = 2,
> APIC_DELIVERY_MODE_NMI = 4,
> APIC_DELIVERY_MODE_INIT = 5,
> APIC_DELIVERY_MODE_EXTINT = 7,
>};
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec.h" 2
>
>extern int pic_mode;
># 40 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec.h"
>extern unsigned long mp_bus_not_pci[(((256) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];
>
>extern unsigned int boot_cpu_physical_apicid;
>extern u8 boot_cpu_apic_version;
>extern unsigned long mp_lapic_addr;
>
>
>extern int smp_found_config;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void get_smp_config(void)
>{
> x86_init.mpparse.get_smp_config(0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void early_get_smp_config(void)
>{
> x86_init.mpparse.get_smp_config(1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void find_smp_config(void)
>{
> x86_init.mpparse.find_smp_config();
>}
>
>
>extern void e820__memblock_alloc_reserved_mpc_new(void);
>extern int enable_update_mptable;
>extern void default_find_smp_config(void);
>extern void default_get_smp_config(unsigned int early);
>
>
>
>
>
>
>
>int generic_processor_info(int apicid, int version);
>
>
>
>struct physid_mask {
> unsigned long mask[(((32768) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];
>};
>
>typedef struct physid_mask physid_mask_t;
># 122 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/mpspec.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long physids_coerce(physid_mask_t *map)
>{
> return map->mask[0];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void physids_promote(unsigned long physids, physid_mask_t *map)
>{
> bitmap_zero((*map).mask, 32768);
> map->mask[0] = physids;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void physid_set_mask_of_physid(int physid, physid_mask_t *map)
>{
> bitmap_zero((*map).mask, 32768);
> set_bit(physid, (*map).mask);
>}
>
>
>
>
>extern physid_mask_t phys_cpu_present_map;
># 39 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h" 2
>
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_x86_cpu_to_node_map; extern __attribute__((section(".data..percpu" ""))) __typeof__(int) x86_cpu_to_node_map; extern __typeof__(int) *x86_cpu_to_node_map_early_ptr; extern __typeof__(int) x86_cpu_to_node_map_early_map[];
># 56 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int early_cpu_to_node(int cpu)
>{
> return *((x86_cpu_to_node_map_early_ptr) ? &(x86_cpu_to_node_map_early_ptr)[cpu] : &(*({ do { const void *__vpp_verify = (typeof((&(x86_cpu_to_node_map)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(x86_cpu_to_node_map)))) *)((&(x86_cpu_to_node_map))))); (typeof((typeof(*((&(x86_cpu_to_node_map)))) *)((&(x86_cpu_to_node_map))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })));
>}
>
>
>
>
>extern cpumask_var_t node_to_cpumask_map[(1 << 10)];
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cpumask *cpumask_of_node(int node)
>{
> return node_to_cpumask_map[node];
>}
>
>
>extern void setup_node_to_cpumask_map(void);
>
>
>
>extern int __node_distance(int, int);
># 103 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/topology.h" 1
># 104 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h" 2
>
>extern const struct cpumask *cpu_coregroup_mask(int cpu);
>extern const struct cpumask *cpu_clustergroup_mask(int cpu);
>
>
>
>
>
>
>
>extern unsigned int __max_die_per_package;
># 123 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
>extern unsigned int __max_logical_packages;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int topology_max_die_per_package(void)
>{
> return __max_die_per_package;
>}
>
>extern int __max_smt_threads;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int topology_max_smt_threads(void)
>{
> return __max_smt_threads;
>}
>
>int topology_update_package_map(unsigned int apicid, unsigned int cpu);
>int topology_update_die_map(unsigned int dieid, unsigned int cpu);
>int topology_phys_to_logical_pkg(unsigned int pkg);
>int topology_phys_to_logical_die(unsigned int die, unsigned int cpu);
>bool topology_is_primary_thread(unsigned int cpu);
>bool topology_smt_supported(void);
># 159 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_fix_phys_package_id(int num, u32 slot)
>{
>}
>
>struct pci_bus;
>int x86_pci_root_bus_node(int bus);
>void x86_pci_root_bus_resources(int bus, struct list_head *resources);
>
>extern bool x86_topology_update;
>
>
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_sched_core_priority; extern __attribute__((section(".data..percpu" "..read_mostly"))) __typeof__(int) sched_core_priority;
>extern unsigned int __attribute__((__section__(".data..read_mostly"))) sysctl_sched_itmt_enabled;
>
>
>void sched_set_itmt_core_prio(int prio, int core_cpu);
>
>
>int sched_set_itmt_support(void);
>
>
>void sched_clear_itmt_support(void);
># 202 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
>extern struct static_key_false arch_scale_freq_key;
>
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_arch_freq_scale; extern __attribute__((section(".data..percpu" ""))) __typeof__(unsigned long) arch_freq_scale;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long arch_scale_freq_capacity(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(arch_freq_scale)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(arch_freq_scale)))) *)((&(arch_freq_scale))))); (typeof((typeof(*((&(arch_freq_scale)))) *)((&(arch_freq_scale))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>
>extern void arch_scale_freq_tick(void);
>
>
>extern void arch_set_max_freq_ratio(bool turbo_disabled);
>void init_freq_invariance(bool secondary, bool cppc_ready);
># 229 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/topology.h"
>void init_freq_invariance_cppc(void);
>
>
>bool amd_set_max_freq_ratio(u64 *ratio);
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h" 2
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h"
>int arch_update_cpu_topology(void);
># 76 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h"
>extern int __attribute__((__section__(".data..read_mostly"))) node_reclaim_distance;
>
>
>
>
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_numa_node; extern __attribute__((section(".data..percpu" ""))) __typeof__(int) numa_node;
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int numa_node_id(void)
>{
> return ({ typeof(numa_node) pscr_ret__; do { const void *__vpp_verify = (typeof((&(numa_node)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(numa_node)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (numa_node)); (typeof(numa_node))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (numa_node)); (typeof(numa_node))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (numa_node)); (typeof(numa_node))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (numa_node)); (typeof(numa_node))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; });
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_to_node(int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(numa_node)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(numa_node)))) *)((&(numa_node))))); (typeof((typeof(*((&(numa_node)))) *)((&(numa_node))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_numa_node(int node)
>{
> do { do { const void *__vpp_verify = (typeof((&(numa_node)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(numa_node)) { case 1: do { u8 pto_val__ = ((u8)(((unsigned long) node) & 0xff)); if (0) { typeof((numa_node)) pto_tmp__; pto_tmp__ = (node); (void)pto_tmp__; } asm volatile("mov" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((numa_node)) : [val] "qi" (pto_val__)); } while (0);break; case 2: do { u16 pto_val__ = ((u16)(((unsigned long) node) & 0xffff)); if (0) { typeof((numa_node)) pto_tmp__; pto_tmp__ = (node); (void)pto_tmp__; } asm volatile("mov" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((numa_node)) : [val] "ri" (pto_val__)); } while (0);break; case 4: do { u32 pto_val__ = ((u32)(((unsigned long) node) & 0xffffffff)); if (0) { typeof((numa_node)) pto_tmp__; pto_tmp__ = (node); (void)pto_tmp__; } asm volatile("mov" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((numa_node)) : [val] "ri" (pto_val__)); } while (0);break; case 8: do { u64 pto_val__ = ((u64)(node)); if (0) { typeof((numa_node)) pto_tmp__; pto_tmp__ = (node); (void)pto_tmp__; } asm volatile("mov" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((numa_node)) : [val] "re" (pto_val__)); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_cpu_numa_node(int cpu, int node)
>{
> (*({ do { const void *__vpp_verify = (typeof((&(numa_node)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(numa_node)))) *)((&(numa_node))))); (typeof((typeof(*((&(numa_node)))) *)((&(numa_node))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })) = node;
>}
># 168 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int numa_mem_id(void)
>{
> return numa_node_id();
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_to_mem(int cpu)
>{
> return cpu_to_node(cpu);
>}
># 209 "/usr/src/linux-5.14.21-150500.53/include/linux/topology.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cpumask *cpu_smt_mask(int cpu)
>{
> return ((*({ do { const void *__vpp_verify = (typeof((&(cpu_sibling_map)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(cpu_sibling_map)))) *)((&(cpu_sibling_map))))); (typeof((typeof(*((&(cpu_sibling_map)))) *)((&(cpu_sibling_map))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cpumask *cpu_cluster_mask(int cpu)
>{
> return (cpu_clustergroup_mask(cpu));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cpumask *cpu_cpu_mask(int cpu)
>{
> return cpumask_of_node(cpu_to_node(cpu));
>}
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h" 2
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>struct vm_area_struct;
># 343 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int gfp_migratetype(const gfp_t gfp_flags)
>{
> ((void)(sizeof(( long)((gfp_flags & ((( gfp_t)0x10u)|(( gfp_t)0x08u))) == ((( gfp_t)0x10u)|(( gfp_t)0x08u))))));
> do { extern void __compiletime_assert_111(void) __attribute__((__error__("BUILD_BUG_ON failed: " "(1UL << GFP_MOVABLE_SHIFT) != ___GFP_MOVABLE"))); if (!(!((1UL << 3) != 0x08u))) __compiletime_assert_111(); } while (0);
> do { extern void __compiletime_assert_112(void) __attribute__((__error__("BUILD_BUG_ON failed: " "(___GFP_MOVABLE >> GFP_MOVABLE_SHIFT) != MIGRATE_MOVABLE"))); if (!(!((0x08u >> 3) != MIGRATE_MOVABLE))) __compiletime_assert_112(); } while (0);
>
> if (__builtin_expect(!!(page_group_by_mobility_disabled), 0))
>  return MIGRATE_UNMOVABLE;
>
>
> return (gfp_flags & ((( gfp_t)0x10u)|(( gfp_t)0x08u))) >> 3;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gfpflags_allow_blocking(const gfp_t gfp_flags)
>{
> return !!(gfp_flags & (( gfp_t)0x400u));
>}
># 380 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gfpflags_normal_context(const gfp_t gfp_flags)
>{
> return (gfp_flags & ((( gfp_t)0x400u) | (( gfp_t)0x20000u))) ==
>  (( gfp_t)0x400u);
>}
># 476 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) enum zone_type gfp_zone(gfp_t flags)
>{
> enum zone_type z;
> int bit = ( int) (flags & ((( gfp_t)0x01u)|(( gfp_t)0x02u)|(( gfp_t)0x04u)|(( gfp_t)0x08u)));
>
> z = (( (ZONE_NORMAL << 0 * 2) | (ZONE_DMA << 0x01u * 2) | (ZONE_NORMAL << 0x02u * 2) | (ZONE_DMA32 << 0x04u * 2) | (ZONE_NORMAL << 0x08u * 2) | (ZONE_DMA << (0x08u | 0x01u) * 2) | (ZONE_MOVABLE << (0x08u | 0x02u) * 2) | (ZONE_DMA32 << (0x08u | 0x04u) * 2)) >> (bit * 2)) &
>      ((1 << 2) - 1);
> ((void)(sizeof(( long)((( 1 << (0x01u | 0x02u) | 1 << (0x01u | 0x04u) | 1 << (0x04u | 0x02u) | 1 << (0x01u | 0x04u | 0x02u) | 1 << (0x08u | 0x02u | 0x01u) | 1 << (0x08u | 0x04u | 0x01u) | 1 << (0x08u | 0x04u | 0x02u) | 1 << (0x08u | 0x04u | 0x01u | 0x02u) ) >> bit) & 1))));
> return z;
>}
># 494 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int gfp_zonelist(gfp_t flags)
>{
>
> if (__builtin_expect(!!(flags & (( gfp_t)0x200000u)), 0))
>  return ZONELIST_NOFALLBACK;
>
> return ZONELIST_FALLBACK;
>}
># 512 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct zonelist *node_zonelist(int nid, gfp_t flags)
>{
> return (node_data[nid])->node_zonelists + gfp_zonelist(flags);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_free_page(struct page *page, int order) { }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_alloc_page(struct page *page, int order) { }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_make_page_accessible(struct page *page)
>{
> return 0;
>}
>
>
>struct page *__alloc_pages(gfp_t gfp, unsigned int order, int preferred_nid,
>  nodemask_t *nodemask);
>
>unsigned long __alloc_pages_bulk(gfp_t gfp, int preferred_nid,
>    nodemask_t *nodemask, int nr_pages,
>    struct list_head *page_list,
>    struct page **page_array);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>alloc_pages_bulk_list(gfp_t gfp, unsigned long nr_pages, struct list_head *list)
>{
> return __alloc_pages_bulk(gfp, numa_mem_id(), ((void *)0), nr_pages, list, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>alloc_pages_bulk_array(gfp_t gfp, unsigned long nr_pages, struct page **page_array)
>{
> return __alloc_pages_bulk(gfp, numa_mem_id(), ((void *)0), nr_pages, ((void *)0), page_array);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>alloc_pages_bulk_array_node(gfp_t gfp, int nid, unsigned long nr_pages, struct page **page_array)
>{
> if (nid == (-1))
>  nid = numa_mem_id();
>
> return __alloc_pages_bulk(gfp, nid, ((void *)0), nr_pages, ((void *)0), page_array);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *
>__alloc_pages_node(int nid, gfp_t gfp_mask, unsigned int order)
>{
> ((void)(sizeof(( long)(nid < 0 || nid >= (1 << 10)))));
> ((void)(sizeof(( long)((gfp_mask & (( gfp_t)0x200000u)) && !node_state((nid), N_ONLINE)))));
>
> return __alloc_pages(gfp_mask, order, nid, ((void *)0));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *alloc_pages_node(int nid, gfp_t gfp_mask,
>      unsigned int order)
>{
> if (nid == (-1))
>  nid = numa_mem_id();
>
> return __alloc_pages_node(nid, gfp_mask, order);
>}
>
>
>struct page *alloc_pages(gfp_t gfp, unsigned int order);
>extern struct page *alloc_pages_vma(gfp_t gfp_mask, int order,
>   struct vm_area_struct *vma, unsigned long addr,
>   bool hugepage);
># 608 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>extern unsigned long __get_free_pages(gfp_t gfp_mask, unsigned int order);
>extern unsigned long get_zeroed_page(gfp_t gfp_mask);
>
>void *alloc_pages_exact(size_t size, gfp_t gfp_mask);
>void free_pages_exact(void *virt, size_t size);
>void * __attribute__((__section__(".meminit.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) alloc_pages_exact_nid(int nid, size_t size, gfp_t gfp_mask);
>
>
>
>
>
>
>
>extern void __free_pages(struct page *page, unsigned int order);
>extern void free_pages(unsigned long addr, unsigned int order);
>
>struct page_frag_cache;
>extern void __page_frag_cache_drain(struct page *page, unsigned int count);
>extern void *page_frag_alloc_align(struct page_frag_cache *nc,
>       unsigned int fragsz, gfp_t gfp_mask,
>       unsigned int align_mask);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *page_frag_alloc(struct page_frag_cache *nc,
>        unsigned int fragsz, gfp_t gfp_mask)
>{
> return page_frag_alloc_align(nc, fragsz, gfp_mask, ~0u);
>}
>
>extern void page_frag_free(void *addr);
>
>
>
>
>void page_alloc_init(void);
>void drain_zone_pages(struct zone *zone, struct per_cpu_pages *pcp);
>void drain_all_pages(struct zone *zone);
>void drain_local_pages(struct zone *zone);
>
>void page_alloc_init_late(void);
># 655 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>extern gfp_t gfp_allowed_mask;
>
>
>bool gfp_pfmemalloc_allowed(gfp_t gfp_mask);
>
>extern void pm_restrict_gfp_mask(void);
>extern void pm_restore_gfp_mask(void);
>
>extern gfp_t vma_thp_gfp_mask(struct vm_area_struct *vma);
>
>
>extern bool pm_suspended_storage(void);
># 676 "/usr/src/linux-5.14.21-150500.53/include/linux/gfp.h"
>extern int alloc_contig_range(unsigned long start, unsigned long end,
>         unsigned migratetype, gfp_t gfp_mask);
>extern struct page *alloc_contig_pages(unsigned long nr_pages, gfp_t gfp_mask,
>           int nid, nodemask_t *nodemask);
>
>void free_contig_range(unsigned long pfn, unsigned long nr_pages);
>
>
>
>extern void init_cma_reserved_pageblock(struct page *page);
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mmap_lock.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/mmap_lock.h"
>extern struct tracepoint __tracepoint_mmap_lock_start_locking;
>extern struct tracepoint __tracepoint_mmap_lock_acquire_returned;
>extern struct tracepoint __tracepoint_mmap_lock_released;
>
>
>
>void __mmap_lock_do_trace_start_locking(struct mm_struct *mm, bool write);
>void __mmap_lock_do_trace_acquire_returned(struct mm_struct *mm, bool write,
>        bool success);
>void __mmap_lock_do_trace_released(struct mm_struct *mm, bool write);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __mmap_lock_trace_start_locking(struct mm_struct *mm,
>         bool write)
>{
> if (static_key_false(&(__tracepoint_mmap_lock_start_locking).key))
>  __mmap_lock_do_trace_start_locking(mm, write);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __mmap_lock_trace_acquire_returned(struct mm_struct *mm,
>            bool write, bool success)
>{
> if (static_key_false(&(__tracepoint_mmap_lock_acquire_returned).key))
>  __mmap_lock_do_trace_acquire_returned(mm, write, success);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __mmap_lock_trace_released(struct mm_struct *mm, bool write)
>{
> if (static_key_false(&(__tracepoint_mmap_lock_released).key))
>  __mmap_lock_do_trace_released(mm, write);
>}
># 63 "/usr/src/linux-5.14.21-150500.53/include/linux/mmap_lock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_init_lock(struct mm_struct *mm)
>{
> do { static struct lock_class_key __key; __init_rwsem((&mm->mmap_lock), "&mm->mmap_lock", &__key); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_write_lock(struct mm_struct *mm)
>{
> __mmap_lock_trace_start_locking(mm, true);
> down_write(&mm->mmap_lock);
> __mmap_lock_trace_acquire_returned(mm, true, true);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_write_lock_nested(struct mm_struct *mm, int subclass)
>{
> __mmap_lock_trace_start_locking(mm, true);
> down_write(&mm->mmap_lock);
> __mmap_lock_trace_acquire_returned(mm, true, true);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mmap_write_lock_killable(struct mm_struct *mm)
>{
> int ret;
>
> __mmap_lock_trace_start_locking(mm, true);
> ret = down_write_killable(&mm->mmap_lock);
> __mmap_lock_trace_acquire_returned(mm, true, ret == 0);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mmap_write_trylock(struct mm_struct *mm)
>{
> bool ret;
>
> __mmap_lock_trace_start_locking(mm, true);
> ret = down_write_trylock(&mm->mmap_lock) != 0;
> __mmap_lock_trace_acquire_returned(mm, true, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_write_unlock(struct mm_struct *mm)
>{
> up_write(&mm->mmap_lock);
> __mmap_lock_trace_released(mm, true);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_write_downgrade(struct mm_struct *mm)
>{
> downgrade_write(&mm->mmap_lock);
> __mmap_lock_trace_acquire_returned(mm, false, true);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_read_lock(struct mm_struct *mm)
>{
> __mmap_lock_trace_start_locking(mm, false);
> down_read(&mm->mmap_lock);
> __mmap_lock_trace_acquire_returned(mm, false, true);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mmap_read_lock_killable(struct mm_struct *mm)
>{
> int ret;
>
> __mmap_lock_trace_start_locking(mm, false);
> ret = down_read_killable(&mm->mmap_lock);
> __mmap_lock_trace_acquire_returned(mm, false, ret == 0);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mmap_read_trylock(struct mm_struct *mm)
>{
> bool ret;
>
> __mmap_lock_trace_start_locking(mm, false);
> ret = down_read_trylock(&mm->mmap_lock) != 0;
> __mmap_lock_trace_acquire_returned(mm, false, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_read_unlock(struct mm_struct *mm)
>{
> up_read(&mm->mmap_lock);
> __mmap_lock_trace_released(mm, false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_read_unlock_non_owner(struct mm_struct *mm)
>{
> up_read(&mm->mmap_lock);
> __mmap_lock_trace_released(mm, false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_assert_locked(struct mm_struct *mm)
>{
> do { (void)(&mm->mmap_lock); } while (0);
> ((void)(sizeof(( long)(!rwsem_is_locked(&mm->mmap_lock)))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mmap_assert_write_locked(struct mm_struct *mm)
>{
> do { (void)(&mm->mmap_lock); } while (0);
> ((void)(sizeof(( long)(!rwsem_is_locked(&mm->mmap_lock)))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mmap_lock_is_contended(struct mm_struct *mm)
>{
> return rwsem_is_contended(&mm->mmap_lock);
>}
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h" 1
># 59 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>struct percpu_ref;
>typedef void (percpu_ref_func_t)(struct percpu_ref *);
>
>
>enum {
> __PERCPU_REF_ATOMIC = 1LU << 0,
> __PERCPU_REF_DEAD = 1LU << 1,
> __PERCPU_REF_ATOMIC_DEAD = __PERCPU_REF_ATOMIC | __PERCPU_REF_DEAD,
>
> __PERCPU_REF_FLAG_BITS = 2,
>};
>
>
>enum {
>
>
>
>
>
>
>
> PERCPU_REF_INIT_ATOMIC = 1 << 0,
>
>
>
>
>
>
> PERCPU_REF_INIT_DEAD = 1 << 1,
>
>
>
>
> PERCPU_REF_ALLOW_REINIT = 1 << 2,
>};
>
>struct percpu_ref_data {
> atomic_long_t count;
> percpu_ref_func_t *release;
> percpu_ref_func_t *confirm_switch;
> bool force_atomic:1;
> bool allow_reinit:1;
> struct callback_head rcu;
> struct percpu_ref *ref;
>};
>
>struct percpu_ref {
>
>
>
>
> unsigned long percpu_count_ptr;
>
>
>
>
>
>
>
> struct percpu_ref_data *data;
>};
>
>int __attribute__((__warn_unused_result__)) percpu_ref_init(struct percpu_ref *ref,
>     percpu_ref_func_t *release, unsigned int flags,
>     gfp_t gfp);
>void percpu_ref_exit(struct percpu_ref *ref);
>void percpu_ref_switch_to_atomic(struct percpu_ref *ref,
>     percpu_ref_func_t *confirm_switch);
>void percpu_ref_switch_to_atomic_sync(struct percpu_ref *ref);
>void percpu_ref_switch_to_percpu(struct percpu_ref *ref);
>void percpu_ref_kill_and_confirm(struct percpu_ref *ref,
>     percpu_ref_func_t *confirm_kill);
>void percpu_ref_resurrect(struct percpu_ref *ref);
>void percpu_ref_reinit(struct percpu_ref *ref);
>bool percpu_ref_is_zero(struct percpu_ref *ref);
># 147 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_ref_kill(struct percpu_ref *ref)
>{
> percpu_ref_kill_and_confirm(ref, ((void *)0));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __ref_is_percpu(struct percpu_ref *ref,
>       unsigned long **percpu_countp)
>{
> unsigned long percpu_ptr;
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
> percpu_ptr = ({ do { extern void __compiletime_assert_113(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(ref->percpu_count_ptr) == sizeof(char) || sizeof(ref->percpu_count_ptr) == sizeof(short) || sizeof(ref->percpu_count_ptr) == sizeof(int) || sizeof(ref->percpu_count_ptr) == sizeof(long)) || sizeof(ref->percpu_count_ptr) == sizeof(long long))) __compiletime_assert_113(); } while (0); (*(const volatile typeof( _Generic((ref->percpu_count_ptr), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (ref->percpu_count_ptr))) *)&(ref->percpu_count_ptr)); });
>
>
>
>
>
>
>
> if (__builtin_expect(!!(percpu_ptr & __PERCPU_REF_ATOMIC_DEAD), 0))
>  return false;
>
> *percpu_countp = (unsigned long *)percpu_ptr;
> return true;
>}
># 198 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_ref_get_many(struct percpu_ref *ref, unsigned long nr)
>{
> unsigned long *percpu_count;
>
> rcu_read_lock();
>
> if (__ref_is_percpu(ref, &percpu_count))
>  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) nr) & 0xff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) nr) & 0xffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) nr) & 0xffffffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u64 pto_val__ = ((u64)(nr)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
> else
>  atomic_long_add(nr, &ref->data->count);
>
> rcu_read_unlock();
>}
># 220 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_ref_get(struct percpu_ref *ref)
>{
> percpu_ref_get_many(ref, 1);
>}
># 235 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_ref_tryget_many(struct percpu_ref *ref,
>       unsigned long nr)
>{
> unsigned long *percpu_count;
> bool ret;
>
> rcu_read_lock();
>
> if (__ref_is_percpu(ref, &percpu_count)) {
>  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) nr) & 0xff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) nr) & 0xffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) nr) & 0xffffffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(nr) && ((nr) == 1 || (nr) == -1)) ? (int)(nr) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (nr); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u64 pto_val__ = ((u64)(nr)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (nr); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>  ret = true;
> } else {
>  ret = atomic_long_add_unless(&ref->data->count, nr, 0);
> }
>
> rcu_read_unlock();
>
> return ret;
>}
># 264 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_ref_tryget(struct percpu_ref *ref)
>{
> return percpu_ref_tryget_many(ref, 1);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_ref_tryget_live_rcu(struct percpu_ref *ref)
>{
> unsigned long *percpu_count;
> bool ret = false;
>
> ({ int __ret_warn_on = !!(!rcu_read_lock_held()); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"), "i" (280), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("114" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "114" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>
> if (__builtin_expect(!!(__ref_is_percpu(ref, &percpu_count)), 1)) {
>  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>  ret = true;
> } else if (!(ref->percpu_count_ptr & __PERCPU_REF_DEAD)) {
>  ret = atomic_long_inc_not_zero(&ref->data->count);
> }
> return ret;
>}
># 306 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_ref_tryget_live(struct percpu_ref *ref)
>{
> bool ret = false;
>
> rcu_read_lock();
> ret = percpu_ref_tryget_live_rcu(ref);
> rcu_read_unlock();
> return ret;
>}
># 326 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_ref_put_many(struct percpu_ref *ref, unsigned long nr)
>{
> unsigned long *percpu_count;
>
> rcu_read_lock();
>
> if (__ref_is_percpu(ref, &percpu_count))
>  do { do { const void *__vpp_verify = (typeof((&(*percpu_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*percpu_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*percpu_count))(nr)) && ((-(typeof(*percpu_count))(nr)) == 1 || (-(typeof(*percpu_count))(nr)) == -1)) ? (int)(-(typeof(*percpu_count))(nr)) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) -(typeof(*percpu_count))(nr)) & 0xff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*percpu_count))(nr)) && ((-(typeof(*percpu_count))(nr)) == 1 || (-(typeof(*percpu_count))(nr)) == -1)) ? (int)(-(typeof(*percpu_count))(nr)) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) -(typeof(*percpu_count))(nr)) & 0xffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*percpu_count))(nr)) && ((-(typeof(*percpu_count))(nr)) == 1 || (-(typeof(*percpu_count))(nr)) == -1)) ? (int)(-(typeof(*percpu_count))(nr)) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) -(typeof(*percpu_count))(nr)) & 0xffffffff)); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*percpu_count))(nr)) && ((-(typeof(*percpu_count))(nr)) == 1 || (-(typeof(*percpu_count))(nr)) == -1)) ? (int)(-(typeof(*percpu_count))(nr)) : 0; if (0) { typeof((*percpu_count)) pao_tmp__; pao_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count))); }); else do { u64 pto_val__ = ((u64)(-(typeof(*percpu_count))(nr))); if (0) { typeof((*percpu_count)) pto_tmp__; pto_tmp__ = (-(typeof(*percpu_count))(nr)); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*percpu_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
> else if (__builtin_expect(!!(atomic_long_sub_and_test(nr, &ref->data->count)), 0))
>  ref->data->release(ref);
>
> rcu_read_unlock();
>}
># 349 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_ref_put(struct percpu_ref *ref)
>{
> percpu_ref_put_many(ref, 1);
>}
># 363 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_ref_is_dying(struct percpu_ref *ref)
>{
> return ref->percpu_count_ptr & __PERCPU_REF_DEAD;
>}
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bit_spinlock.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/bit_spinlock.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bit_spin_lock(int bitnum, unsigned long *addr)
>{
>
>
>
>
>
>
>
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
>
> while (__builtin_expect(!!(test_and_set_bit_lock(bitnum, addr)), 0)) {
>  do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>  do {
>   cpu_relax();
>  } while (test_bit(bitnum, addr));
>  do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> }
>
> (void)0;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int bit_spin_trylock(int bitnum, unsigned long *addr)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
>
> if (__builtin_expect(!!(test_and_set_bit_lock(bitnum, addr)), 0)) {
>  do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>  return 0;
> }
>
> (void)0;
> return 1;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bit_spin_unlock(int bitnum, unsigned long *addr)
>{
>
>
>
>
> clear_bit_unlock(bitnum, addr);
>
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
> (void)0;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __bit_spin_unlock(int bitnum, unsigned long *addr)
>{
>
>
>
>
> __clear_bit_unlock(bitnum, addr);
>
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
> (void)0;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int bit_spin_is_locked(int bitnum, unsigned long *addr)
>{
>
> return test_bit(bitnum, addr);
>
>
>
>
>
>}
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/shrinker.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/shrinker.h"
>struct shrink_control {
> gfp_t gfp_mask;
>
>
> int nid;
>
>
>
>
>
>
> unsigned long nr_to_scan;
>
>
>
>
>
>
> unsigned long nr_scanned;
>
>
> struct mem_cgroup *memcg;
>};
># 60 "/usr/src/linux-5.14.21-150500.53/include/linux/shrinker.h"
>struct shrinker {
> unsigned long (*count_objects)(struct shrinker *,
>           struct shrink_control *sc);
> unsigned long (*scan_objects)(struct shrinker *,
>          struct shrink_control *sc);
>
> long batch;
> int seeks;
> unsigned flags;
>
>
> struct list_head list;
>
>
> int id;
>
>
> atomic_long_t *nr_deferred;
>};
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/shrinker.h"
>extern int prealloc_shrinker(struct shrinker *shrinker);
>extern void register_shrinker_prepared(struct shrinker *shrinker);
>extern int register_shrinker(struct shrinker *shrinker);
>extern void unregister_shrinker(struct shrinker *shrinker);
>extern void free_prealloced_shrinker(struct shrinker *shrinker);
>extern void synchronize_shrinkers(void);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/resource.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/resource.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/resource.h"
>struct rusage {
> struct __kernel_old_timeval ru_utime;
> struct __kernel_old_timeval ru_stime;
> __kernel_long_t ru_maxrss;
> __kernel_long_t ru_ixrss;
> __kernel_long_t ru_idrss;
> __kernel_long_t ru_isrss;
> __kernel_long_t ru_minflt;
> __kernel_long_t ru_majflt;
> __kernel_long_t ru_nswap;
> __kernel_long_t ru_inblock;
> __kernel_long_t ru_oublock;
> __kernel_long_t ru_msgsnd;
> __kernel_long_t ru_msgrcv;
> __kernel_long_t ru_nsignals;
> __kernel_long_t ru_nvcsw;
> __kernel_long_t ru_nivcsw;
>};
>
>struct rlimit {
> __kernel_ulong_t rlim_cur;
> __kernel_ulong_t rlim_max;
>};
>
>
>
>struct rlimit64 {
> __u64 rlim_cur;
> __u64 rlim_max;
>};
># 78 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/resource.h"
># 1 "./arch/x86/include/generated/uapi/asm/resource.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/resource.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/resource.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/resource.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/resource.h" 2
># 79 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/resource.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/resource.h" 2
>
>
>struct task_struct;
>
>void getrusage(struct task_struct *p, int who, struct rusage *ru);
>int do_prlimit(struct task_struct *tsk, unsigned int resource,
>  struct rlimit *new_rlim, struct rlimit *old_rlim);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ext.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stacktrace.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/stacktrace.h" 2
>
>struct task_struct;
>struct pt_regs;
>
>
>void stack_trace_print(const unsigned long *trace, unsigned int nr_entries,
>         int spaces);
>int stack_trace_snprint(char *buf, size_t size, const unsigned long *entries,
>   unsigned int nr_entries, int spaces);
>unsigned int stack_trace_save(unsigned long *store, unsigned int size,
>         unsigned int skipnr);
>unsigned int stack_trace_save_tsk(struct task_struct *task,
>      unsigned long *store, unsigned int size,
>      unsigned int skipnr);
>unsigned int stack_trace_save_regs(struct pt_regs *regs, unsigned long *store,
>       unsigned int size, unsigned int skipnr);
>unsigned int stack_trace_save_user(unsigned long *store, unsigned int size);
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/stacktrace.h"
>typedef bool (*stack_trace_consume_fn)(void *cookie, unsigned long addr);
># 53 "/usr/src/linux-5.14.21-150500.53/include/linux/stacktrace.h"
>void arch_stack_walk(stack_trace_consume_fn consume_entry, void *cookie,
>       struct task_struct *task, struct pt_regs *regs);
># 73 "/usr/src/linux-5.14.21-150500.53/include/linux/stacktrace.h"
>int arch_stack_walk_reliable(stack_trace_consume_fn consume_entry, void *cookie,
>        struct task_struct *task);
>
>void arch_stack_walk_user(stack_trace_consume_fn consume_entry, void *cookie,
>     const struct pt_regs *regs);
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/stacktrace.h"
>int stack_trace_save_tsk_reliable(struct task_struct *tsk, unsigned long *store,
>      unsigned int size);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ext.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stackdepot.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/stackdepot.h"
>typedef u32 depot_stack_handle_t;
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/stackdepot.h"
>int stack_depot_init(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int stack_depot_early_init(void) { return 0; }
>
>
>depot_stack_handle_t stack_depot_save(unsigned long *entries,
>          unsigned int nr_entries, gfp_t gfp_flags);
>
>unsigned int stack_depot_fetch(depot_stack_handle_t handle,
>          unsigned long **entries);
>
>unsigned int filter_irq_stacks(unsigned long *entries, unsigned int nr_entries);
>
>int stack_depot_snprint(depot_stack_handle_t handle, char *buf, size_t size,
>         int spaces);
>
>void stack_depot_print(depot_stack_handle_t stack);
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ext.h" 2
>
>struct pglist_data;
>struct page_ext_operations {
> size_t offset;
> size_t size;
> bool (*need)(void);
> void (*init)(void);
>};
>
>
>
>enum page_ext_flags {
> PAGE_EXT_OWNER,
> PAGE_EXT_OWNER_ALLOCATED,
>
>
>
>
>};
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ext.h"
>struct page_ext {
> unsigned long flags;
>};
>
>extern unsigned long page_ext_size;
>extern void pgdat_page_ext_init(struct pglist_data *pgdat);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ext_init_flatmem(void)
>{
>}
>extern void page_ext_init(void);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ext_init_flatmem_late(void)
>{
>}
># 58 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ext.h"
>struct page_ext *lookup_page_ext(const struct page *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page_ext *page_ext_next(struct page_ext *curr)
>{
> void *next = curr;
> next += page_ext_size;
> return next;
>}
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ref.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ref.h"
>extern struct tracepoint __tracepoint_page_ref_set;
>extern struct tracepoint __tracepoint_page_ref_mod;
>extern struct tracepoint __tracepoint_page_ref_mod_and_test;
>extern struct tracepoint __tracepoint_page_ref_mod_and_return;
>extern struct tracepoint __tracepoint_page_ref_mod_unless;
>extern struct tracepoint __tracepoint_page_ref_freeze;
>extern struct tracepoint __tracepoint_page_ref_unfreeze;
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/page_ref.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_set(struct page *page, int v)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_mod(struct page *page, int v)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_mod_and_test(struct page *page, int v, int ret)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_mod_and_return(struct page *page, int v, int ret)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_mod_unless(struct page *page, int v, int u)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_freeze(struct page *page, int v, int ret)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __page_ref_unfreeze(struct page *page, int v)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_count(const struct page *page)
>{
> return atomic_read(&page->_refcount);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_count(const struct page *page)
>{
> return atomic_read(&((typeof(page))_compound_head(page))->_refcount);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_count(struct page *page, int v)
>{
> atomic_set(&page->_refcount, v);
> if (false)
>  __page_ref_set(page, v);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_page_count(struct page *page)
>{
> set_page_count(page, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ref_add(struct page *page, int nr)
>{
> atomic_add(nr, &page->_refcount);
> if (false)
>  __page_ref_mod(page, nr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ref_sub(struct page *page, int nr)
>{
> atomic_sub(nr, &page->_refcount);
> if (false)
>  __page_ref_mod(page, -nr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_sub_return(struct page *page, int nr)
>{
> int ret = atomic_sub_return(nr, &page->_refcount);
>
> if (false)
>  __page_ref_mod_and_return(page, -nr, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ref_inc(struct page *page)
>{
> atomic_inc(&page->_refcount);
> if (false)
>  __page_ref_mod(page, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ref_dec(struct page *page)
>{
> atomic_dec(&page->_refcount);
> if (false)
>  __page_ref_mod(page, -1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_sub_and_test(struct page *page, int nr)
>{
> int ret = atomic_sub_and_test(nr, &page->_refcount);
>
> if (false)
>  __page_ref_mod_and_test(page, -nr, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_inc_return(struct page *page)
>{
> int ret = atomic_inc_return(&page->_refcount);
>
> if (false)
>  __page_ref_mod_and_return(page, 1, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_dec_and_test(struct page *page)
>{
> int ret = atomic_dec_and_test(&page->_refcount);
>
> if (false)
>  __page_ref_mod_and_test(page, -1, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_dec_return(struct page *page)
>{
> int ret = atomic_dec_return(&page->_refcount);
>
> if (false)
>  __page_ref_mod_and_return(page, -1, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_add_unless(struct page *page, int nr, int u)
>{
> int ret = atomic_add_unless(&page->_refcount, nr, u);
>
> if (false)
>  __page_ref_mod_unless(page, nr, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_ref_freeze(struct page *page, int count)
>{
> int ret = __builtin_expect(!!(atomic_cmpxchg(&page->_refcount, count, 0) == count), 1);
>
> if (false)
>  __page_ref_freeze(page, count, ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_ref_unfreeze(struct page *page, int count)
>{
> ((void)(sizeof(( long)(page_count(page) != 0))));
> ((void)(sizeof(( long)(count == 0))));
>
> atomic_set_release(&page->_refcount, count);
> if (false)
>  __page_ref_unfreeze(page, count);
>}
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/overflow.h" 1
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/overflow.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) __must_check_overflow(bool overflow)
>{
> return __builtin_expect(!!(overflow), 0);
>}
># 262 "/usr/src/linux-5.14.21-150500.53/include/linux/overflow.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t __attribute__((__warn_unused_result__)) size_mul(size_t factor1, size_t factor2)
>{
> size_t bytes;
>
> if (__must_check_overflow(({ typeof(factor1) __a = (factor1); typeof(factor2) __b = (factor2); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_mul_overflow(__a, __b, __d); })))
>  return (~(size_t)0);
>
> return bytes;
>}
># 282 "/usr/src/linux-5.14.21-150500.53/include/linux/overflow.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t __attribute__((__warn_unused_result__)) size_add(size_t addend1, size_t addend2)
>{
> size_t bytes;
>
> if (__must_check_overflow(({ typeof(addend1) __a = (addend1); typeof(addend2) __b = (addend2); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_add_overflow(__a, __b, __d); })))
>  return (~(size_t)0);
>
> return bytes;
>}
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/overflow.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t __attribute__((__warn_unused_result__)) size_sub(size_t minuend, size_t subtrahend)
>{
> size_t bytes;
>
> if (minuend == (~(size_t)0) || subtrahend == (~(size_t)0) ||
>     __must_check_overflow(({ typeof(minuend) __a = (minuend); typeof(subtrahend) __b = (subtrahend); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_sub_overflow(__a, __b, __d); })))
>  return (~(size_t)0);
>
> return bytes;
>}
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sizes.h" 1
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sched.h" 1
># 92 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sched.h"
>struct clone_args {
> __u64 __attribute__((aligned(8))) flags;
> __u64 __attribute__((aligned(8))) pidfd;
> __u64 __attribute__((aligned(8))) child_tid;
> __u64 __attribute__((aligned(8))) parent_tid;
> __u64 __attribute__((aligned(8))) exit_signal;
> __u64 __attribute__((aligned(8))) stack;
> __u64 __attribute__((aligned(8))) stack_size;
> __u64 __attribute__((aligned(8))) tls;
> __u64 __attribute__((aligned(8))) set_tid;
> __u64 __attribute__((aligned(8))) set_tid_size;
> __u64 __attribute__((aligned(8))) cgroup;
>};
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h" 1
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void INIT_LIST_HEAD_RCU(struct list_head *list)
>{
> do { do { extern void __compiletime_assert_115(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(list->next) == sizeof(char) || sizeof(list->next) == sizeof(short) || sizeof(list->next) == sizeof(int) || sizeof(list->next) == sizeof(long)) || sizeof(list->next) == sizeof(long long))) __compiletime_assert_115(); } while (0); do { *(volatile typeof(list->next) *)&(list->next) = (list); } while (0); } while (0);
> do { do { extern void __compiletime_assert_116(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(list->prev) == sizeof(char) || sizeof(list->prev) == sizeof(short) || sizeof(list->prev) == sizeof(int) || sizeof(list->prev) == sizeof(long)) || sizeof(list->prev) == sizeof(long long))) __compiletime_assert_116(); } while (0); do { *(volatile typeof(list->prev) *)&(list->prev) = (list); } while (0); } while (0);
>}
># 85 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_add_rcu(struct list_head *new,
>  struct list_head *prev, struct list_head *next)
>{
> if (!__list_add_valid(new, prev, next))
>  return;
>
> new->next = next;
> new->prev = prev;
> do { uintptr_t _r_a_p__v = (uintptr_t)(new); ; if (__builtin_constant_p(new) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_117(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(char) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(short) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(int) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long)) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long long))) __compiletime_assert_117(); } while (0); do { *(volatile typeof(((*((struct list_head **)(&(prev)->next))))) *)&(((*((struct list_head **)(&(prev)->next))))) = ((typeof((*((struct list_head **)(&(prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_118(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)))) __compiletime_assert_118(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_119(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long long))) __compiletime_assert_119(); } while (0); do { *(volatile typeof(*&(*((struct list_head **)(&(prev)->next)))) *)&(*&(*((struct list_head **)(&(prev)->next)))) = ((typeof(*((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)) *)((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> next->prev = new;
>}
># 113 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_add_rcu(struct list_head *new, struct list_head *head)
>{
> __list_add_rcu(new, head, head->next);
>}
># 134 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_add_tail_rcu(struct list_head *new,
>     struct list_head *head)
>{
> __list_add_rcu(new, head->prev, head);
>}
># 164 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_del_rcu(struct list_head *entry)
>{
> __list_del_entry(entry);
> entry->prev = ((void *) 0x122 + (0xdead000000000000UL));
>}
># 190 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_del_init_rcu(struct hlist_node *n)
>{
> if (!hlist_unhashed(n)) {
>  __hlist_del(n);
>  do { do { extern void __compiletime_assert_120(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_120(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (((void *)0)); } while (0); } while (0);
> }
>}
># 206 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_replace_rcu(struct list_head *old,
>    struct list_head *new)
>{
> new->next = old->next;
> new->prev = old->prev;
> do { uintptr_t _r_a_p__v = (uintptr_t)(new); ; if (__builtin_constant_p(new) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_121(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(char) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(short) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(int) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(long)) || sizeof(((*((struct list_head **)(&(new->prev)->next))))) == sizeof(long long))) __compiletime_assert_121(); } while (0); do { *(volatile typeof(((*((struct list_head **)(&(new->prev)->next))))) *)&(((*((struct list_head **)(&(new->prev)->next))))) = ((typeof((*((struct list_head **)(&(new->prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_122(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long)))) __compiletime_assert_122(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_123(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct list_head **)(&(new->prev)->next)))) == sizeof(long long))) __compiletime_assert_123(); } while (0); do { *(volatile typeof(*&(*((struct list_head **)(&(new->prev)->next)))) *)&(*&(*((struct list_head **)(&(new->prev)->next)))) = ((typeof(*((typeof((*((struct list_head **)(&(new->prev)->next)))))_r_a_p__v)) *)((typeof((*((struct list_head **)(&(new->prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> new->next->prev = new;
> old->prev = ((void *) 0x122 + (0xdead000000000000UL));
>}
># 235 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __list_splice_init_rcu(struct list_head *list,
>       struct list_head *prev,
>       struct list_head *next,
>       void (*sync)(void))
>{
> struct list_head *first = list->next;
> struct list_head *last = list->prev;
>
>
>
>
>
>
>
> INIT_LIST_HEAD_RCU(list);
># 258 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
> sync();
> __kcsan_check_access(&(*first), sizeof(*first), (1 << 0) | (1 << 3));
> __kcsan_check_access(&(*last), sizeof(*last), (1 << 0) | (1 << 3));
># 270 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
> last->next = next;
> do { uintptr_t _r_a_p__v = (uintptr_t)(first); ; if (__builtin_constant_p(first) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_124(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(char) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(short) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(int) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long)) || sizeof(((*((struct list_head **)(&(prev)->next))))) == sizeof(long long))) __compiletime_assert_124(); } while (0); do { *(volatile typeof(((*((struct list_head **)(&(prev)->next))))) *)&(((*((struct list_head **)(&(prev)->next))))) = ((typeof((*((struct list_head **)(&(prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_125(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)))) __compiletime_assert_125(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_126(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct list_head **)(&(prev)->next)))) == sizeof(long long))) __compiletime_assert_126(); } while (0); do { *(volatile typeof(*&(*((struct list_head **)(&(prev)->next)))) *)&(*&(*((struct list_head **)(&(prev)->next)))) = ((typeof(*((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)) *)((typeof((*((struct list_head **)(&(prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> first->prev = prev;
> next->prev = last;
>}
># 283 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_splice_init_rcu(struct list_head *list,
>     struct list_head *head,
>     void (*sync)(void))
>{
> if (!list_empty(list))
>  __list_splice_init_rcu(list, head, head->next, sync);
>}
># 298 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void list_splice_tail_init_rcu(struct list_head *list,
>          struct list_head *head,
>          void (*sync)(void))
>{
> if (!list_empty(list))
>  __list_splice_init_rcu(list, head->prev, head, sync);
>}
># 512 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_del_rcu(struct hlist_node *n)
>{
> __hlist_del(n);
> do { do { extern void __compiletime_assert_127(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_127(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (((void *) 0x122 + (0xdead000000000000UL))); } while (0); } while (0);
>}
># 525 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_replace_rcu(struct hlist_node *old,
>     struct hlist_node *new)
>{
> struct hlist_node *next = old->next;
>
> new->next = next;
> do { do { extern void __compiletime_assert_128(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(new->pprev) == sizeof(char) || sizeof(new->pprev) == sizeof(short) || sizeof(new->pprev) == sizeof(int) || sizeof(new->pprev) == sizeof(long)) || sizeof(new->pprev) == sizeof(long long))) __compiletime_assert_128(); } while (0); do { *(volatile typeof(new->pprev) *)&(new->pprev) = (old->pprev); } while (0); } while (0);
> do { uintptr_t _r_a_p__v = (uintptr_t)(new); ; if (__builtin_constant_p(new) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_129(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((*(struct hlist_node **)new->pprev)) == sizeof(char) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(short) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(int) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(long)) || sizeof((*(struct hlist_node **)new->pprev)) == sizeof(long long))) __compiletime_assert_129(); } while (0); do { *(volatile typeof((*(struct hlist_node **)new->pprev)) *)&((*(struct hlist_node **)new->pprev)) = ((typeof(*(struct hlist_node **)new->pprev))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_130(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(char) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(short) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(int) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long)))) __compiletime_assert_130(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_131(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(char) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(short) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(int) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long)) || sizeof(*&*(struct hlist_node **)new->pprev) == sizeof(long long))) __compiletime_assert_131(); } while (0); do { *(volatile typeof(*&*(struct hlist_node **)new->pprev) *)&(*&*(struct hlist_node **)new->pprev) = ((typeof(*((typeof(*(struct hlist_node **)new->pprev))_r_a_p__v)) *)((typeof(*(struct hlist_node **)new->pprev))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> if (next)
>  do { do { extern void __compiletime_assert_132(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(new->next->pprev) == sizeof(char) || sizeof(new->next->pprev) == sizeof(short) || sizeof(new->next->pprev) == sizeof(int) || sizeof(new->next->pprev) == sizeof(long)) || sizeof(new->next->pprev) == sizeof(long long))) __compiletime_assert_132(); } while (0); do { *(volatile typeof(new->next->pprev) *)&(new->next->pprev) = (&new->next); } while (0); } while (0);
> do { do { extern void __compiletime_assert_133(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(old->pprev) == sizeof(char) || sizeof(old->pprev) == sizeof(short) || sizeof(old->pprev) == sizeof(int) || sizeof(old->pprev) == sizeof(long)) || sizeof(old->pprev) == sizeof(long long))) __compiletime_assert_133(); } while (0); do { *(volatile typeof(old->pprev) *)&(old->pprev) = (((void *) 0x122 + (0xdead000000000000UL))); } while (0); } while (0);
>}
># 548 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlists_swap_heads_rcu(struct hlist_head *left, struct hlist_head *right)
>{
> struct hlist_node *node1 = left->first;
> struct hlist_node *node2 = right->first;
>
> do { uintptr_t _r_a_p__v = (uintptr_t)(node2); ; if (__builtin_constant_p(node2) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_134(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((left->first)) == sizeof(char) || sizeof((left->first)) == sizeof(short) || sizeof((left->first)) == sizeof(int) || sizeof((left->first)) == sizeof(long)) || sizeof((left->first)) == sizeof(long long))) __compiletime_assert_134(); } while (0); do { *(volatile typeof((left->first)) *)&((left->first)) = ((typeof(left->first))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_135(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&left->first) == sizeof(char) || sizeof(*&left->first) == sizeof(short) || sizeof(*&left->first) == sizeof(int) || sizeof(*&left->first) == sizeof(long)))) __compiletime_assert_135(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_136(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&left->first) == sizeof(char) || sizeof(*&left->first) == sizeof(short) || sizeof(*&left->first) == sizeof(int) || sizeof(*&left->first) == sizeof(long)) || sizeof(*&left->first) == sizeof(long long))) __compiletime_assert_136(); } while (0); do { *(volatile typeof(*&left->first) *)&(*&left->first) = ((typeof(*((typeof(left->first))_r_a_p__v)) *)((typeof(left->first))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> do { uintptr_t _r_a_p__v = (uintptr_t)(node1); ; if (__builtin_constant_p(node1) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_137(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((right->first)) == sizeof(char) || sizeof((right->first)) == sizeof(short) || sizeof((right->first)) == sizeof(int) || sizeof((right->first)) == sizeof(long)) || sizeof((right->first)) == sizeof(long long))) __compiletime_assert_137(); } while (0); do { *(volatile typeof((right->first)) *)&((right->first)) = ((typeof(right->first))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_138(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&right->first) == sizeof(char) || sizeof(*&right->first) == sizeof(short) || sizeof(*&right->first) == sizeof(int) || sizeof(*&right->first) == sizeof(long)))) __compiletime_assert_138(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_139(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&right->first) == sizeof(char) || sizeof(*&right->first) == sizeof(short) || sizeof(*&right->first) == sizeof(int) || sizeof(*&right->first) == sizeof(long)) || sizeof(*&right->first) == sizeof(long long))) __compiletime_assert_139(); } while (0); do { *(volatile typeof(*&right->first) *)&(*&right->first) = ((typeof(*((typeof(right->first))_r_a_p__v)) *)((typeof(right->first))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> do { do { extern void __compiletime_assert_140(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(node2->pprev) == sizeof(char) || sizeof(node2->pprev) == sizeof(short) || sizeof(node2->pprev) == sizeof(int) || sizeof(node2->pprev) == sizeof(long)) || sizeof(node2->pprev) == sizeof(long long))) __compiletime_assert_140(); } while (0); do { *(volatile typeof(node2->pprev) *)&(node2->pprev) = (&left->first); } while (0); } while (0);
> do { do { extern void __compiletime_assert_141(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(node1->pprev) == sizeof(char) || sizeof(node1->pprev) == sizeof(short) || sizeof(node1->pprev) == sizeof(int) || sizeof(node1->pprev) == sizeof(long)) || sizeof(node1->pprev) == sizeof(long long))) __compiletime_assert_141(); } while (0); do { *(volatile typeof(node1->pprev) *)&(node1->pprev) = (&right->first); } while (0); } while (0);
>}
># 585 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_head_rcu(struct hlist_node *n,
>     struct hlist_head *h)
>{
> struct hlist_node *first = h->first;
>
> n->next = first;
> do { do { extern void __compiletime_assert_142(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_142(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&h->first); } while (0); } while (0);
> do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_143(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(char) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(short) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(int) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)(&(h)->first))))) == sizeof(long long))) __compiletime_assert_143(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)(&(h)->first))))) *)&(((*((struct hlist_node **)(&(h)->first))))) = ((typeof((*((struct hlist_node **)(&(h)->first)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_144(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long)))) __compiletime_assert_144(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_145(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)(&(h)->first)))) == sizeof(long long))) __compiletime_assert_145(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)(&(h)->first)))) *)&(*&(*((struct hlist_node **)(&(h)->first)))) = ((typeof(*((typeof((*((struct hlist_node **)(&(h)->first)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)(&(h)->first)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> if (first)
>  do { do { extern void __compiletime_assert_146(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(first->pprev) == sizeof(char) || sizeof(first->pprev) == sizeof(short) || sizeof(first->pprev) == sizeof(int) || sizeof(first->pprev) == sizeof(long)) || sizeof(first->pprev) == sizeof(long long))) __compiletime_assert_146(); } while (0); do { *(volatile typeof(first->pprev) *)&(first->pprev) = (&n->next); } while (0); } while (0);
>}
># 616 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_tail_rcu(struct hlist_node *n,
>          struct hlist_head *h)
>{
> struct hlist_node *i, *last = ((void *)0);
>
>
> for (i = h->first; i; i = i->next)
>  last = i;
>
> if (last) {
>  n->next = last->next;
>  do { do { extern void __compiletime_assert_147(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_147(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&last->next); } while (0); } while (0);
>  do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_148(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(char) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(short) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(int) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)(&(last)->next))))) == sizeof(long long))) __compiletime_assert_148(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)(&(last)->next))))) *)&(((*((struct hlist_node **)(&(last)->next))))) = ((typeof((*((struct hlist_node **)(&(last)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_149(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(long)))) __compiletime_assert_149(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_150(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)(&(last)->next)))) == sizeof(long long))) __compiletime_assert_150(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)(&(last)->next)))) *)&(*&(*((struct hlist_node **)(&(last)->next)))) = ((typeof(*((typeof((*((struct hlist_node **)(&(last)->next)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)(&(last)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> } else {
>  hlist_add_head_rcu(n, h);
> }
>}
># 652 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_before_rcu(struct hlist_node *n,
>     struct hlist_node *next)
>{
> do { do { extern void __compiletime_assert_151(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_151(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (next->pprev); } while (0); } while (0);
> n->next = next;
> do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_152(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(char) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(short) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(int) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)((n)->pprev))))) == sizeof(long long))) __compiletime_assert_152(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)((n)->pprev))))) *)&(((*((struct hlist_node **)((n)->pprev))))) = ((typeof((*((struct hlist_node **)((n)->pprev)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_153(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long)))) __compiletime_assert_153(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_154(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)((n)->pprev)))) == sizeof(long long))) __compiletime_assert_154(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)((n)->pprev)))) *)&(*&(*((struct hlist_node **)((n)->pprev)))) = ((typeof(*((typeof((*((struct hlist_node **)((n)->pprev)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)((n)->pprev)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> do { do { extern void __compiletime_assert_155(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(next->pprev) == sizeof(char) || sizeof(next->pprev) == sizeof(short) || sizeof(next->pprev) == sizeof(int) || sizeof(next->pprev) == sizeof(long)) || sizeof(next->pprev) == sizeof(long long))) __compiletime_assert_155(); } while (0); do { *(volatile typeof(next->pprev) *)&(next->pprev) = (&n->next); } while (0); } while (0);
>}
># 679 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_add_behind_rcu(struct hlist_node *n,
>     struct hlist_node *prev)
>{
> n->next = prev->next;
> do { do { extern void __compiletime_assert_156(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->pprev) == sizeof(char) || sizeof(n->pprev) == sizeof(short) || sizeof(n->pprev) == sizeof(int) || sizeof(n->pprev) == sizeof(long)) || sizeof(n->pprev) == sizeof(long long))) __compiletime_assert_156(); } while (0); do { *(volatile typeof(n->pprev) *)&(n->pprev) = (&prev->next); } while (0); } while (0);
> do { uintptr_t _r_a_p__v = (uintptr_t)(n); ; if (__builtin_constant_p(n) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_157(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(char) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(short) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(int) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(long)) || sizeof(((*((struct hlist_node **)(&(prev)->next))))) == sizeof(long long))) __compiletime_assert_157(); } while (0); do { *(volatile typeof(((*((struct hlist_node **)(&(prev)->next))))) *)&(((*((struct hlist_node **)(&(prev)->next))))) = ((typeof((*((struct hlist_node **)(&(prev)->next)))))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_158(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long)))) __compiletime_assert_158(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_159(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(char) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(short) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(int) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long)) || sizeof(*&(*((struct hlist_node **)(&(prev)->next)))) == sizeof(long long))) __compiletime_assert_159(); } while (0); do { *(volatile typeof(*&(*((struct hlist_node **)(&(prev)->next)))) *)&(*&(*((struct hlist_node **)(&(prev)->next)))) = ((typeof(*((typeof((*((struct hlist_node **)(&(prev)->next)))))_r_a_p__v)) *)((typeof((*((struct hlist_node **)(&(prev)->next)))))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> if (n->next)
>  do { do { extern void __compiletime_assert_160(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(n->next->pprev) == sizeof(char) || sizeof(n->next->pprev) == sizeof(short) || sizeof(n->next->pprev) == sizeof(int) || sizeof(n->next->pprev) == sizeof(long)) || sizeof(n->next->pprev) == sizeof(long long))) __compiletime_assert_160(); } while (0); do { *(volatile typeof(n->next->pprev) *)&(n->next->pprev) = (&n->next); } while (0); } while (0);
>}
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h" 1
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>struct mutex;
># 111 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>typedef struct refcount_struct {
> atomic_t refs;
>} refcount_t;
>
>
>
>
>
>enum refcount_saturation_type {
> REFCOUNT_ADD_NOT_ZERO_OVF,
> REFCOUNT_ADD_OVF,
> REFCOUNT_ADD_UAF,
> REFCOUNT_SUB_UAF,
> REFCOUNT_DEC_LEAK,
>};
>
>void refcount_warn_saturate(refcount_t *r, enum refcount_saturation_type t);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void refcount_set(refcount_t *r, int n)
>{
> atomic_set(&r->refs, n);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int refcount_read(const refcount_t *r)
>{
> return atomic_read(&r->refs);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool __refcount_add_not_zero(int i, refcount_t *r, int *oldp)
>{
> int old = refcount_read(r);
>
> do {
>  if (!old)
>   break;
> } while (!atomic_try_cmpxchg_relaxed(&r->refs, &old, old + i));
>
> if (oldp)
>  *oldp = old;
>
> if (__builtin_expect(!!(old < 0 || old + i < 0), 0))
>  refcount_warn_saturate(r, REFCOUNT_ADD_NOT_ZERO_OVF);
>
> return old;
>}
># 186 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool refcount_add_not_zero(int i, refcount_t *r)
>{
> return __refcount_add_not_zero(i, r, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __refcount_add(int i, refcount_t *r, int *oldp)
>{
> int old = atomic_fetch_add_relaxed(i, &r->refs);
>
> if (oldp)
>  *oldp = old;
>
> if (__builtin_expect(!!(!old), 0))
>  refcount_warn_saturate(r, REFCOUNT_ADD_UAF);
> else if (__builtin_expect(!!(old < 0 || old + i < 0), 0))
>  refcount_warn_saturate(r, REFCOUNT_ADD_OVF);
>}
># 220 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void refcount_add(int i, refcount_t *r)
>{
> __refcount_add(i, r, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool __refcount_inc_not_zero(refcount_t *r, int *oldp)
>{
> return __refcount_add_not_zero(1, r, oldp);
>}
># 243 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool refcount_inc_not_zero(refcount_t *r)
>{
> return __refcount_inc_not_zero(r, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __refcount_inc(refcount_t *r, int *oldp)
>{
> __refcount_add(1, r, oldp);
>}
># 265 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void refcount_inc(refcount_t *r)
>{
> __refcount_inc(r, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool __refcount_sub_and_test(int i, refcount_t *r, int *oldp)
>{
> int old = atomic_fetch_sub_release(i, &r->refs);
>
> if (oldp)
>  *oldp = old;
>
> if (old == i) {
>  __asm__ __volatile__("": : :"memory");
>  return true;
> }
>
> if (__builtin_expect(!!(old < 0 || old - i < 0), 0))
>  refcount_warn_saturate(r, REFCOUNT_SUB_UAF);
>
> return false;
>}
># 308 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool refcount_sub_and_test(int i, refcount_t *r)
>{
> return __refcount_sub_and_test(i, r, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool __refcount_dec_and_test(refcount_t *r, int *oldp)
>{
> return __refcount_sub_and_test(1, r, oldp);
>}
># 331 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool refcount_dec_and_test(refcount_t *r)
>{
> return __refcount_dec_and_test(r, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __refcount_dec(refcount_t *r, int *oldp)
>{
> int old = atomic_fetch_sub_release(1, &r->refs);
>
> if (oldp)
>  *oldp = old;
>
> if (__builtin_expect(!!(old <= 1), 0))
>  refcount_warn_saturate(r, REFCOUNT_DEC_LEAK);
>}
># 357 "/usr/src/linux-5.14.21-150500.53/include/linux/refcount.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void refcount_dec(refcount_t *r)
>{
> __refcount_dec(r, ((void *)0));
>}
>
>extern __attribute__((__warn_unused_result__)) bool refcount_dec_if_one(refcount_t *r);
>extern __attribute__((__warn_unused_result__)) bool refcount_dec_not_one(refcount_t *r);
>extern __attribute__((__warn_unused_result__)) bool refcount_dec_and_mutex_lock(refcount_t *r, struct mutex *lock);
>extern __attribute__((__warn_unused_result__)) bool refcount_dec_and_lock(refcount_t *r, spinlock_t *lock);
>extern __attribute__((__warn_unused_result__)) bool refcount_dec_and_lock_irqsave(refcount_t *r,
>             spinlock_t *lock,
>             unsigned long *flags);
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h" 2
>
>enum pid_type
>{
> PIDTYPE_PID,
> PIDTYPE_TGID,
> PIDTYPE_PGID,
> PIDTYPE_SID,
> PIDTYPE_MAX,
>};
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h"
>struct upid {
> int nr;
> struct pid_namespace *ns;
>};
>
>struct pid
>{
> refcount_t count;
> unsigned int level;
> spinlock_t lock;
>
> struct hlist_head tasks[PIDTYPE_MAX];
> struct hlist_head inodes;
>
> wait_queue_head_t wait_pidfd;
> struct callback_head rcu;
> struct upid numbers[1];
>};
>
>extern struct pid init_struct_pid;
>
>extern const struct file_operations pidfd_fops;
>
>struct file;
>
>extern struct pid *pidfd_pid(const struct file *file);
>struct pid *pidfd_get_pid(unsigned int fd, unsigned int *flags);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid *get_pid(struct pid *pid)
>{
> if (pid)
>  refcount_inc(&pid->count);
> return pid;
>}
>
>extern void put_pid(struct pid *pid);
>extern struct task_struct *pid_task(struct pid *pid, enum pid_type);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pid_has_task(struct pid *pid, enum pid_type type)
>{
> return !hlist_empty(&pid->tasks[type]);
>}
>extern struct task_struct *get_pid_task(struct pid *pid, enum pid_type);
>
>extern struct pid *get_task_pid(struct task_struct *task, enum pid_type type);
>
>
>
>
>extern void attach_pid(struct task_struct *task, enum pid_type);
>extern void detach_pid(struct task_struct *task, enum pid_type);
>extern void change_pid(struct task_struct *task, enum pid_type,
>   struct pid *pid);
>extern void exchange_tids(struct task_struct *task, struct task_struct *old);
>extern void transfer_pid(struct task_struct *old, struct task_struct *new,
>    enum pid_type);
>
>struct pid_namespace;
>extern struct pid_namespace init_pid_ns;
>
>extern int pid_max;
>extern int pid_max_min, pid_max_max;
># 125 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h"
>extern struct pid *find_pid_ns(int nr, struct pid_namespace *ns);
>extern struct pid *find_vpid(int nr);
>
>
>
>
>extern struct pid *find_get_pid(int nr);
>extern struct pid *find_ge_pid(int nr, struct pid_namespace *);
>
>extern struct pid *alloc_pid(struct pid_namespace *ns, pid_t *set_tid,
>        size_t set_tid_size);
>extern void free_pid(struct pid *pid);
>extern void disable_pid_allocation(struct pid_namespace *ns);
># 149 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid_namespace *ns_of_pid(struct pid *pid)
>{
> struct pid_namespace *ns = ((void *)0);
> if (pid)
>  ns = pid->numbers[pid->level].ns;
> return ns;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_child_reaper(struct pid *pid)
>{
> return pid->numbers[pid->level].nr == 1;
>}
># 179 "/usr/src/linux-5.14.21-150500.53/include/linux/pid.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t pid_nr(struct pid *pid)
>{
> pid_t nr = 0;
> if (pid)
>  nr = pid->numbers[0].nr;
> return nr;
>}
>
>pid_t pid_nr_ns(struct pid *pid, struct pid_namespace *ns);
>pid_t pid_vnr(struct pid *pid);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sem.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sem.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ipc.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/uidgid.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/uidgid.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/highuid.h" 1
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/highuid.h"
>extern int overflowuid;
>extern int overflowgid;
>
>extern void __bad_uid(void);
>extern void __bad_gid(void);
># 82 "/usr/src/linux-5.14.21-150500.53/include/linux/highuid.h"
>extern int fs_overflowuid;
>extern int fs_overflowgid;
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/uidgid.h" 2
>
>struct user_namespace;
>extern struct user_namespace init_user_ns;
>
>typedef struct {
> uid_t val;
>} kuid_t;
>
>
>typedef struct {
> gid_t val;
>} kgid_t;
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) uid_t __kuid_val(kuid_t uid)
>{
> return uid.val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) gid_t __kgid_val(kgid_t gid)
>{
> return gid.val;
>}
># 61 "/usr/src/linux-5.14.21-150500.53/include/linux/uidgid.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uid_eq(kuid_t left, kuid_t right)
>{
> return __kuid_val(left) == __kuid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gid_eq(kgid_t left, kgid_t right)
>{
> return __kgid_val(left) == __kgid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uid_gt(kuid_t left, kuid_t right)
>{
> return __kuid_val(left) > __kuid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gid_gt(kgid_t left, kgid_t right)
>{
> return __kgid_val(left) > __kgid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uid_gte(kuid_t left, kuid_t right)
>{
> return __kuid_val(left) >= __kuid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gid_gte(kgid_t left, kgid_t right)
>{
> return __kgid_val(left) >= __kgid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uid_lt(kuid_t left, kuid_t right)
>{
> return __kuid_val(left) < __kuid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gid_lt(kgid_t left, kgid_t right)
>{
> return __kgid_val(left) < __kgid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uid_lte(kuid_t left, kuid_t right)
>{
> return __kuid_val(left) <= __kuid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gid_lte(kgid_t left, kgid_t right)
>{
> return __kgid_val(left) <= __kgid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uid_valid(kuid_t uid)
>{
> return __kuid_val(uid) != (uid_t) -1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gid_valid(kgid_t gid)
>{
> return __kgid_val(gid) != (gid_t) -1;
>}
>
>
>
>extern kuid_t make_kuid(struct user_namespace *from, uid_t uid);
>extern kgid_t make_kgid(struct user_namespace *from, gid_t gid);
>
>extern uid_t from_kuid(struct user_namespace *to, kuid_t uid);
>extern gid_t from_kgid(struct user_namespace *to, kgid_t gid);
>extern uid_t from_kuid_munged(struct user_namespace *to, kuid_t uid);
>extern gid_t from_kgid_munged(struct user_namespace *to, kgid_t gid);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kuid_has_mapping(struct user_namespace *ns, kuid_t uid)
>{
> return from_kuid(ns, uid) != (uid_t) -1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kgid_has_mapping(struct user_namespace *ns, kgid_t gid)
>{
> return from_kgid(ns, gid) != (gid_t) -1;
>}
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/ipc.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rhashtable-types.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/rhashtable-types.h"
>struct rhash_head {
> struct rhash_head *next;
>};
>
>struct rhlist_head {
> struct rhash_head rhead;
> struct rhlist_head *next;
>};
>
>struct bucket_table;
>
>
>
>
>
>
>struct rhashtable_compare_arg {
> struct rhashtable *ht;
> const void *key;
>};
>
>typedef u32 (*rht_hashfn_t)(const void *data, u32 len, u32 seed);
>typedef u32 (*rht_obj_hashfn_t)(const void *data, u32 len, u32 seed);
>typedef int (*rht_obj_cmpfn_t)(struct rhashtable_compare_arg *arg,
>          const void *obj);
># 56 "/usr/src/linux-5.14.21-150500.53/include/linux/rhashtable-types.h"
>struct rhashtable_params {
> u16 nelem_hint;
> u16 key_len;
> u16 key_offset;
> u16 head_offset;
> unsigned int max_size;
> u16 min_size;
> bool automatic_shrinking;
> rht_hashfn_t hashfn;
> rht_obj_hashfn_t obj_hashfn;
> rht_obj_cmpfn_t obj_cmpfn;
>};
># 81 "/usr/src/linux-5.14.21-150500.53/include/linux/rhashtable-types.h"
>struct rhashtable {
> struct bucket_table *tbl;
> unsigned int key_len;
> unsigned int max_elems;
> struct rhashtable_params p;
> bool rhlist;
> struct work_struct run_work;
> struct mutex mutex;
> spinlock_t lock;
> atomic_t nelems;
>};
>
>
>
>
>
>struct rhltable {
> struct rhashtable ht;
>};
>
>
>
>
>
>
>struct rhashtable_walker {
> struct list_head list;
> struct bucket_table *tbl;
>};
># 120 "/usr/src/linux-5.14.21-150500.53/include/linux/rhashtable-types.h"
>struct rhashtable_iter {
> struct rhashtable *ht;
> struct rhash_head *p;
> struct rhlist_head *list;
> struct rhashtable_walker walker;
> unsigned int slot;
> unsigned int skip;
> bool end_of_table;
>};
>
>int rhashtable_init(struct rhashtable *ht,
>      const struct rhashtable_params *params);
>int rhltable_init(struct rhltable *hlt,
>    const struct rhashtable_params *params);
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/ipc.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipc.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipc.h"
>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;
> unsigned short seq;
>};
>
>
># 1 "./arch/x86/include/generated/uapi/asm/ipcbuf.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/ipcbuf.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/ipcbuf.h"
>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[4 - sizeof(__kernel_mode_t)];
> unsigned short seq;
> unsigned short __pad2;
> __kernel_ulong_t __unused1;
> __kernel_ulong_t __unused2;
>};
># 1 "./arch/x86/include/generated/uapi/asm/ipcbuf.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipc.h" 2
># 58 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipc.h"
>struct ipc_kludge {
> struct msgbuf *msgp;
> long msgtyp;
>};
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/ipc.h" 2
>
>
>
>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;
> unsigned long seq;
> void *security;
>
> struct rhash_head khtnode;
>
> struct callback_head rcu;
> refcount_t refcount;
>} __attribute__((__aligned__((1 << (6))))) __attribute__((__designated_init__));
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sem.h" 2
># 25 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sem.h"
>struct semid_ds {
> struct ipc_perm sem_perm;
> __kernel_old_time_t sem_otime;
> __kernel_old_time_t sem_ctime;
> struct sem *sem_base;
> struct sem_queue *sem_pending;
> struct sem_queue **sem_pending_last;
> struct sem_undo *undo;
> unsigned short sem_nsems;
>};
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sembuf.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/ipcbuf.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sembuf.h" 2
># 18 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/sembuf.h"
>struct semid64_ds {
> struct ipc64_perm sem_perm;
>
>
>
>
>
>
> __kernel_long_t sem_otime;
> __kernel_ulong_t __unused1;
> __kernel_long_t sem_ctime;
> __kernel_ulong_t __unused2;
>
> __kernel_ulong_t sem_nsems;
> __kernel_ulong_t __unused3;
> __kernel_ulong_t __unused4;
>};
># 38 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sem.h" 2
>
>
>struct sembuf {
> unsigned short sem_num;
> short sem_op;
> short sem_flg;
>};
>
>
>union semun {
> int val;
> struct semid_ds *buf;
> unsigned short *array;
> struct seminfo *__buf;
> void *__pad;
>};
>
>struct seminfo {
> int semmap;
> int semmni;
> int semmns;
> int semmnu;
> int semmsl;
> int semopm;
> int semume;
> int semusz;
> int semvmx;
> int semaem;
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/sem.h" 2
>
>struct task_struct;
>struct sem_undo_list;
>
>
>
>struct sysv_sem {
> struct sem_undo_list *undo_list;
>};
>
>extern int copy_semundo(unsigned long clone_flags, struct task_struct *tsk);
>extern void exit_sem(struct task_struct *tsk);
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/shm.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/shm.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/hugetlb_encode.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/shm.h" 2
># 28 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/shm.h"
>struct shmid_ds {
> struct ipc_perm shm_perm;
> int shm_segsz;
> __kernel_old_time_t shm_atime;
> __kernel_old_time_t shm_dtime;
> __kernel_old_time_t shm_ctime;
> __kernel_ipc_pid_t shm_cpid;
> __kernel_ipc_pid_t shm_lpid;
> unsigned short shm_nattch;
> unsigned short shm_unused;
> void *shm_unused2;
> void *shm_unused3;
>};
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/shmbuf.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/shmbuf.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/shmbuf.h"
>struct shmid64_ds {
> struct ipc64_perm shm_perm;
> size_t shm_segsz;
>
> long shm_atime;
> long shm_dtime;
> long shm_ctime;
># 40 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/shmbuf.h"
> __kernel_pid_t shm_cpid;
> __kernel_pid_t shm_lpid;
> unsigned long shm_nattch;
> unsigned long __unused4;
> unsigned long __unused5;
>};
>
>struct shminfo64 {
> unsigned long shmmax;
> unsigned long shmmin;
> unsigned long shmmni;
> unsigned long shmseg;
> unsigned long shmall;
> unsigned long __unused1;
> unsigned long __unused2;
> unsigned long __unused3;
> unsigned long __unused4;
>};
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/shmbuf.h" 2
># 44 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/shm.h" 2
># 93 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/shm.h"
>struct shminfo {
> int shmmax;
> int shmmin;
> int shmmni;
> int shmseg;
> int shmall;
>};
>
>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;
>};
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/shm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/shmparam.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/shm.h" 2
>
>struct file;
>
>
>struct sysv_shm {
> struct list_head shm_clist;
>};
>
>long do_shmat(int shmid, char *shmaddr, int shmflg, unsigned long *addr,
>       unsigned long shmlba);
>bool is_file_shm_hugepages(struct file *file);
>void exit_shm(struct task_struct *task);
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/plist.h" 1
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/plist.h"
>struct plist_head {
> struct list_head node_list;
>};
>
>struct plist_node {
> int prio;
> struct list_head prio_list;
> struct list_head node_list;
>};
># 121 "/usr/src/linux-5.14.21-150500.53/include/linux/plist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>plist_head_init(struct plist_head *head)
>{
> INIT_LIST_HEAD(&head->node_list);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void plist_node_init(struct plist_node *node, int prio)
>{
> node->prio = prio;
> INIT_LIST_HEAD(&node->prio_list);
> INIT_LIST_HEAD(&node->node_list);
>}
>
>extern void plist_add(struct plist_node *node, struct plist_head *head);
>extern void plist_del(struct plist_node *node, struct plist_head *head);
>
>extern void plist_requeue(struct plist_node *node, struct plist_head *head);
># 210 "/usr/src/linux-5.14.21-150500.53/include/linux/plist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int plist_head_empty(const struct plist_head *head)
>{
> return list_empty(&head->node_list);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int plist_node_empty(const struct plist_node *node)
>{
> return list_empty(&node->node_list);
>}
># 280 "/usr/src/linux-5.14.21-150500.53/include/linux/plist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct plist_node *plist_first(const struct plist_head *head)
>{
> return ({ void *__mptr = (void *)(head->node_list.next); do { extern void __compiletime_assert_161(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(head->node_list.next)), typeof(((struct plist_node *)0)->node_list)) && !__builtin_types_compatible_p(typeof(*(head->node_list.next)), typeof(void))))) __compiletime_assert_161(); } while (0); ((struct plist_node *)(__mptr - __builtin_offsetof(struct plist_node, node_list))); })
>                                  ;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct plist_node *plist_last(const struct plist_head *head)
>{
> return ({ void *__mptr = (void *)(head->node_list.prev); do { extern void __compiletime_assert_162(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(head->node_list.prev)), typeof(((struct plist_node *)0)->node_list)) && !__builtin_types_compatible_p(typeof(*(head->node_list.prev)), typeof(void))))) __compiletime_assert_162(); } while (0); ((struct plist_node *)(__mptr - __builtin_offsetof(struct plist_node, node_list))); })
>                                  ;
>}
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer_defs.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h" 2
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/timerqueue.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/timerqueue.h"
>struct timerqueue_node {
> struct rb_node node;
> ktime_t expires;
>};
>
>struct timerqueue_head {
> struct rb_root_cached rb_root;
>};
>
>
>extern bool timerqueue_add(struct timerqueue_head *head,
>      struct timerqueue_node *node);
>extern bool timerqueue_del(struct timerqueue_head *head,
>      struct timerqueue_node *node);
>extern struct timerqueue_node *timerqueue_iterate_next(
>      struct timerqueue_node *node);
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/timerqueue.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct timerqueue_node *timerqueue_getnext(struct timerqueue_head *head)
>{
> struct rb_node *leftmost = (&head->rb_root)->rb_leftmost;
>
> return ({ void *__mptr = (void *)(leftmost); do { extern void __compiletime_assert_163(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(leftmost)), typeof(((struct timerqueue_node *)0)->node)) && !__builtin_types_compatible_p(typeof(*(leftmost)), typeof(void))))) __compiletime_assert_163(); } while (0); ((struct timerqueue_node *)(__mptr - __builtin_offsetof(struct timerqueue_node, node))); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void timerqueue_init(struct timerqueue_node *node)
>{
> ((&node->node)->__rb_parent_color = (unsigned long)(&node->node));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool timerqueue_node_queued(struct timerqueue_node *node)
>{
> return !((&node->node)->__rb_parent_color == (unsigned long)(&node->node));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool timerqueue_node_expires(struct timerqueue_node *node)
>{
> return node->expires;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void timerqueue_init_head(struct timerqueue_head *head)
>{
> head->rb_root = (struct rb_root_cached) { {((void *)0), }, ((void *)0) };
>}
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h" 2
>
>struct hrtimer_clock_base;
>struct hrtimer_cpu_base;
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>enum hrtimer_mode {
> HRTIMER_MODE_ABS = 0x00,
> HRTIMER_MODE_REL = 0x01,
> HRTIMER_MODE_PINNED = 0x02,
> HRTIMER_MODE_SOFT = 0x04,
> HRTIMER_MODE_HARD = 0x08,
>
> HRTIMER_MODE_ABS_PINNED = HRTIMER_MODE_ABS | HRTIMER_MODE_PINNED,
> HRTIMER_MODE_REL_PINNED = HRTIMER_MODE_REL | HRTIMER_MODE_PINNED,
>
> HRTIMER_MODE_ABS_SOFT = HRTIMER_MODE_ABS | HRTIMER_MODE_SOFT,
> HRTIMER_MODE_REL_SOFT = HRTIMER_MODE_REL | HRTIMER_MODE_SOFT,
>
> HRTIMER_MODE_ABS_PINNED_SOFT = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_SOFT,
> HRTIMER_MODE_REL_PINNED_SOFT = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_SOFT,
>
> HRTIMER_MODE_ABS_HARD = HRTIMER_MODE_ABS | HRTIMER_MODE_HARD,
> HRTIMER_MODE_REL_HARD = HRTIMER_MODE_REL | HRTIMER_MODE_HARD,
>
> HRTIMER_MODE_ABS_PINNED_HARD = HRTIMER_MODE_ABS_PINNED | HRTIMER_MODE_HARD,
> HRTIMER_MODE_REL_PINNED_HARD = HRTIMER_MODE_REL_PINNED | HRTIMER_MODE_HARD,
>};
>
>
>
>
>enum hrtimer_restart {
> HRTIMER_NORESTART,
> HRTIMER_RESTART,
>};
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>struct hrtimer {
> struct timerqueue_node node;
> ktime_t _softexpires;
> enum hrtimer_restart (*function)(struct hrtimer *);
> struct hrtimer_clock_base *base;
> u8 state;
> u8 is_rel;
> u8 is_soft;
> u8 is_hard;
>};
># 136 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>struct hrtimer_sleeper {
> struct hrtimer timer;
> struct task_struct *task;
>};
># 159 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>struct hrtimer_clock_base {
> struct hrtimer_cpu_base *cpu_base;
> unsigned int index;
> clockid_t clockid;
> seqcount_raw_spinlock_t seq;
> struct hrtimer *running;
> struct timerqueue_head active;
> ktime_t (*get_time)(void);
> ktime_t offset;
>} __attribute__((__aligned__((1 << (6)))));
>
>enum hrtimer_base_type {
> HRTIMER_BASE_MONOTONIC,
> HRTIMER_BASE_REALTIME,
> HRTIMER_BASE_BOOTTIME,
> HRTIMER_BASE_TAI,
> HRTIMER_BASE_MONOTONIC_SOFT,
> HRTIMER_BASE_REALTIME_SOFT,
> HRTIMER_BASE_BOOTTIME_SOFT,
> HRTIMER_BASE_TAI_SOFT,
> HRTIMER_MAX_CLOCK_BASES,
>};
># 214 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>struct hrtimer_cpu_base {
> raw_spinlock_t lock;
> unsigned int cpu;
> unsigned int active_bases;
> unsigned int clock_was_set_seq;
> unsigned int hres_active : 1,
>     in_hrtirq : 1,
>     hang_detected : 1,
>     softirq_activated : 1;
>
> unsigned int nr_events;
> unsigned short nr_retries;
> unsigned short nr_hangs;
> unsigned int max_hang_time;
>
>
>
>
>
> ktime_t expires_next;
> struct hrtimer *next_timer;
> ktime_t softirq_expires_next;
> struct hrtimer *softirq_next_timer;
> struct hrtimer_clock_base clock_base[HRTIMER_MAX_CLOCK_BASES];
>} __attribute__((__aligned__((1 << (6)))));
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_set_expires(struct hrtimer *timer, ktime_t time)
>{
> timer->node.expires = time;
> timer->_softexpires = time;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_set_expires_range(struct hrtimer *timer, ktime_t time, ktime_t delta)
>{
> timer->_softexpires = time;
> timer->node.expires = ktime_add_safe(time, delta);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_set_expires_range_ns(struct hrtimer *timer, ktime_t time, u64 delta)
>{
> timer->_softexpires = time;
> timer->node.expires = ktime_add_safe(time, ns_to_ktime(delta));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_set_expires_tv64(struct hrtimer *timer, s64 tv64)
>{
> timer->node.expires = tv64;
> timer->_softexpires = tv64;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_add_expires(struct hrtimer *timer, ktime_t time)
>{
> timer->node.expires = ktime_add_safe(timer->node.expires, time);
> timer->_softexpires = ktime_add_safe(timer->_softexpires, time);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_add_expires_ns(struct hrtimer *timer, u64 ns)
>{
> timer->node.expires = ((timer->node.expires) + (ns));
> timer->_softexpires = ((timer->_softexpires) + (ns));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t hrtimer_get_expires(const struct hrtimer *timer)
>{
> return timer->node.expires;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t hrtimer_get_softexpires(const struct hrtimer *timer)
>{
> return timer->_softexpires;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 hrtimer_get_expires_tv64(const struct hrtimer *timer)
>{
> return timer->node.expires;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 hrtimer_get_softexpires_tv64(const struct hrtimer *timer)
>{
> return timer->_softexpires;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 hrtimer_get_expires_ns(const struct hrtimer *timer)
>{
> return ktime_to_ns(timer->node.expires);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t hrtimer_expires_remaining(const struct hrtimer *timer)
>{
> return ((timer->node.expires) - (timer->base->get_time()));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t hrtimer_cb_get_time(struct hrtimer *timer)
>{
> return timer->base->get_time();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int hrtimer_is_hres_active(struct hrtimer *timer)
>{
> return 1 ?
>  timer->base->cpu_base->hres_active : 0;
>}
>
>
>struct clock_event_device;
>
>extern void hrtimer_interrupt(struct clock_event_device *dev);
>
>extern unsigned int hrtimer_resolution;
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t
>__hrtimer_expires_remaining_adjusted(const struct hrtimer *timer, ktime_t now)
>{
> ktime_t rem = ((timer->node.expires) - (now));
>
>
>
>
>
> if (0 && timer->is_rel)
>  rem -= hrtimer_resolution;
> return rem;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t
>hrtimer_expires_remaining_adjusted(const struct hrtimer *timer)
>{
> return __hrtimer_expires_remaining_adjusted(timer,
>          timer->base->get_time());
>}
>
>
>extern void timerfd_clock_was_set(void);
>extern void timerfd_resume(void);
>
>
>
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_tick_cpu_device; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct tick_device) tick_cpu_device;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_cancel_wait_running(struct hrtimer *timer)
>{
> cpu_relax();
>}
>
>
>
>
>
>extern void hrtimer_init(struct hrtimer *timer, clockid_t which_clock,
>    enum hrtimer_mode mode);
>extern void hrtimer_init_sleeper(struct hrtimer_sleeper *sl, clockid_t clock_id,
>     enum hrtimer_mode mode);
># 386 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_init_on_stack(struct hrtimer *timer,
>      clockid_t which_clock,
>      enum hrtimer_mode mode)
>{
> hrtimer_init(timer, which_clock, mode);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_init_sleeper_on_stack(struct hrtimer_sleeper *sl,
>       clockid_t clock_id,
>       enum hrtimer_mode mode)
>{
> hrtimer_init_sleeper(sl, clock_id, mode);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_hrtimer_on_stack(struct hrtimer *timer) { }
>
>
>
>extern void hrtimer_start_range_ns(struct hrtimer *timer, ktime_t tim,
>       u64 range_ns, const enum hrtimer_mode mode);
># 415 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_start(struct hrtimer *timer, ktime_t tim,
>     const enum hrtimer_mode mode)
>{
> hrtimer_start_range_ns(timer, tim, 0, mode);
>}
>
>extern int hrtimer_cancel(struct hrtimer *timer);
>extern int hrtimer_try_to_cancel(struct hrtimer *timer);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_start_expires(struct hrtimer *timer,
>      enum hrtimer_mode mode)
>{
> u64 delta;
> ktime_t soft, hard;
> soft = hrtimer_get_softexpires(timer);
> hard = hrtimer_get_expires(timer);
> delta = ktime_to_ns(((hard) - (soft)));
> hrtimer_start_range_ns(timer, soft, delta, mode);
>}
>
>void hrtimer_sleeper_start_expires(struct hrtimer_sleeper *sl,
>       enum hrtimer_mode mode);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hrtimer_restart(struct hrtimer *timer)
>{
> hrtimer_start_expires(timer, HRTIMER_MODE_ABS);
>}
>
>
>extern ktime_t __hrtimer_get_remaining(const struct hrtimer *timer, bool adjust);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ktime_t hrtimer_get_remaining(const struct hrtimer *timer)
>{
> return __hrtimer_get_remaining(timer, false);
>}
>
>extern u64 hrtimer_get_next_event(void);
>extern u64 hrtimer_next_event_without(const struct hrtimer *exclude);
>
>extern bool hrtimer_active(const struct hrtimer *timer);
># 468 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool hrtimer_is_queued(struct hrtimer *timer)
>{
>
> return !!(({ do { extern void __compiletime_assert_164(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(timer->state) == sizeof(char) || sizeof(timer->state) == sizeof(short) || sizeof(timer->state) == sizeof(int) || sizeof(timer->state) == sizeof(long)) || sizeof(timer->state) == sizeof(long long))) __compiletime_assert_164(); } while (0); (*(const volatile typeof( _Generic((timer->state), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (timer->state))) *)&(timer->state)); }) & 0x01);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int hrtimer_callback_running(struct hrtimer *timer)
>{
> return timer->base->running == timer;
>}
>
>
>extern u64
>hrtimer_forward(struct hrtimer *timer, ktime_t now, ktime_t interval);
># 503 "/usr/src/linux-5.14.21-150500.53/include/linux/hrtimer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 hrtimer_forward_now(struct hrtimer *timer,
>          ktime_t interval)
>{
> return hrtimer_forward(timer, timer->base->get_time(), interval);
>}
>
>
>
>extern int nanosleep_copyout(struct restart_block *, struct timespec64 *);
>extern long hrtimer_nanosleep(ktime_t rqtp, const enum hrtimer_mode mode,
>         const clockid_t clockid);
>
>extern int schedule_hrtimeout_range(ktime_t *expires, u64 delta,
>        const enum hrtimer_mode mode);
>extern int schedule_hrtimeout_range_clock(ktime_t *expires,
>       u64 delta,
>       const enum hrtimer_mode mode,
>       clockid_t clock_id);
>extern int schedule_hrtimeout(ktime_t *expires, const enum hrtimer_mode mode);
>
>
>extern void hrtimer_run_queues(void);
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) hrtimers_init(void);
>
>
>extern void sysrq_timer_list_show(void);
>
>int hrtimers_prepare_cpu(unsigned int cpu);
>
>int hrtimers_dead_cpu(unsigned int cpu);
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/seccomp.h" 1
># 60 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/seccomp.h"
>struct seccomp_data {
> int nr;
> __u32 arch;
> __u64 instruction_pointer;
> __u64 args[6];
>};
>
>struct seccomp_notif_sizes {
> __u16 seccomp_notif;
> __u16 seccomp_notif_resp;
> __u16 seccomp_data;
>};
>
>struct seccomp_notif {
> __u64 id;
> __u32 pid;
> __u32 flags;
> struct seccomp_data data;
>};
># 109 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/seccomp.h"
>struct seccomp_notif_resp {
> __u64 id;
> __s64 val;
> __s32 error;
> __u32 flags;
>};
># 128 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/seccomp.h"
>struct seccomp_notif_addfd {
> __u64 id;
> __u32 flags;
> __u32 srcfd;
> __u32 newfd;
> __u32 newfd_flags;
>};
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h" 2
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/seccomp.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unistd.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/unistd.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unistd.h" 2
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unistd.h"
># 1 "./arch/x86/include/generated/uapi/asm/unistd_64.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unistd.h" 2
># 1 "./arch/x86/include/generated/asm/unistd_64_x32.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unistd.h" 2
># 1 "./arch/x86/include/generated/asm/unistd_32_ia32.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/unistd.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/seccomp.h" 2
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ia32_unistd.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/seccomp.h" 2
># 39 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/seccomp.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/seccomp.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/seccomp.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/unistd.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/seccomp.h" 2
># 31 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/seccomp.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const int *get_compat_mode1_syscalls(void)
>{
> static const int mode1_syscalls_32[] = {
>  3, 4,
>  1, 119,
>  -1,
> };
> return mode1_syscalls_32;
>}
># 40 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/seccomp.h" 2
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h" 2
>
>struct seccomp_filter;
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h"
>struct seccomp {
> int mode;
> atomic_t filter_count;
> struct seccomp_filter *filter;
>};
>
>
>extern int __secure_computing(const struct seccomp_data *sd);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int secure_computing(void)
>{
> if (__builtin_expect(!!(test_bit(SYSCALL_WORK_BIT_SECCOMP, &((struct thread_info *)get_current())->syscall_work)), 0))
>  return __secure_computing(((void *)0));
> return 0;
>}
>
>
>
>
>extern long prctl_get_seccomp(void);
>extern long prctl_set_seccomp(unsigned long, void *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int seccomp_mode(struct seccomp *s)
>{
> return s->mode;
>}
># 93 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h"
>extern void seccomp_filter_release(struct task_struct *tsk);
>extern void get_seccomp_filter(struct task_struct *tsk);
># 107 "/usr/src/linux-5.14.21-150500.53/include/linux/seccomp.h"
>extern long seccomp_get_filter(struct task_struct *task,
>          unsigned long filter_off, void *data);
>extern long seccomp_get_metadata(struct task_struct *task,
>     unsigned long filter_off, void *data);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/latencytop.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/latencytop.h"
>struct task_struct;
>
>
>
>
>
>
>struct latency_record {
> unsigned long backtrace[12];
> unsigned int count;
> unsigned long time;
> unsigned long max;
>};
>
>
>
>extern int latencytop_enabled;
>void __account_scheduler_latency(struct task_struct *task, int usecs, int inter);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>account_scheduler_latency(struct task_struct *task, int usecs, int inter)
>{
> if (__builtin_expect(!!(latencytop_enabled), 0))
>  __account_scheduler_latency(task, usecs, inter);
>}
>
>void clear_tsk_latency_tracing(struct task_struct *p);
>
>int sysctl_latencytop(struct ctl_table *table, int write, void *buffer,
>  size_t *lenp, loff_t *ppos);
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/prio.h" 1
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/prio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long nice_to_rlimit(long nice)
>{
> return (19 - nice + 1);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long rlimit_to_nice(long prio)
>{
> return (19 - prio + 1);
>}
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/types.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/types.h"
>struct task_cputime {
> u64 stime;
> u64 utime;
> unsigned long long sum_exec_runtime;
>};
># 29 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/signal_types.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/signal_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/signal.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/signal.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/signal.h"
>typedef unsigned long old_sigset_t;
>
>typedef struct {
> unsigned long sig[(64 / 64)];
>} sigset_t;
># 37 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/signal.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/signal.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/signal.h"
>struct siginfo;
># 70 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/signal.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/signal-defs.h" 1
># 81 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/signal-defs.h"
>typedef void __signalfn_t(int);
>typedef __signalfn_t *__sighandler_t;
>
>typedef void __restorefn_t(void);
>typedef __restorefn_t *__sigrestore_t;
># 71 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/signal.h" 2
># 104 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/signal.h"
>typedef struct sigaltstack {
> void *ss_sp;
> int ss_flags;
> size_t ss_size;
>} stack_t;
># 38 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/signal.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/signal.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/siginfo.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/siginfo.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/siginfo.h" 1
>
>
>
>
>
>
>
>typedef union sigval {
> int sival_int;
> void *sival_ptr;
>} sigval_t;
># 32 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/siginfo.h"
>union __sifields {
>
> struct {
>  __kernel_pid_t _pid;
>  __kernel_uid32_t _uid;
> } _kill;
>
>
> struct {
>  __kernel_timer_t _tid;
>  int _overrun;
>  sigval_t _sigval;
>  int _sys_private;
> } _timer;
>
>
> struct {
>  __kernel_pid_t _pid;
>  __kernel_uid32_t _uid;
>  sigval_t _sigval;
> } _rt;
>
>
> struct {
>  __kernel_pid_t _pid;
>  __kernel_uid32_t _uid;
>  int _status;
>  __kernel_clock_t _utime;
>  __kernel_clock_t _stime;
> } _sigchld;
>
>
> struct {
>  void *_addr;
># 74 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/siginfo.h"
>  union {
>
>   int _trapno;
>
>
>
>
>   short _addr_lsb;
>
>   struct {
>    char _dummy_bnd[(__alignof__(void *) < sizeof(short) ? sizeof(short) : __alignof__(void *))];
>    void *_lower;
>    void *_upper;
>   } _addr_bnd;
>
>   struct {
>    char _dummy_pkey[(__alignof__(void *) < sizeof(short) ? sizeof(short) : __alignof__(void *))];
>    __u32 _pkey;
>   } _addr_pkey;
>
>   struct {
>    unsigned long _data;
>    __u32 _type;
>    __u32 _flags;
>   } _perf;
>  };
> } _sigfault;
>
>
> struct {
>  long _band;
>  int _fd;
> } _sigpoll;
>
>
> struct {
>  void *_call_addr;
>  int _syscall;
>  unsigned int _arch;
> } _sigsys;
>};
># 134 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/siginfo.h"
>typedef struct siginfo {
> union {
>  struct { int si_signo; int si_errno; int si_code; union __sifields _sifields; };
>  int _si_pad[128/sizeof(int)];
> };
>} siginfo_t;
># 335 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/siginfo.h"
>typedef struct sigevent {
> sigval_t sigev_value;
> int sigev_signo;
> int sigev_notify;
> union {
>  int _pad[((64 - (sizeof(int) * 2 + sizeof(sigval_t))) / sizeof(int))];
>   int _tid;
>
>  struct {
>   void (*_function)(sigval_t);
>   void *_attribute;
>  } _sigev_thread;
> } _sigev_un;
>} sigevent_t;
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/siginfo.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/signal.h" 2
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/signal_types.h" 2
>
>typedef struct kernel_siginfo {
> struct { int si_signo; int si_errno; int si_code; union __sifields _sifields; };
>} kernel_siginfo_t;
>
>struct ucounts;
>
>
>
>
>
>struct sigqueue {
> struct list_head list;
> int flags;
> kernel_siginfo_t info;
> struct ucounts *ucounts;
>};
>
>
>
>
>struct sigpending {
> struct list_head list;
> sigset_t signal;
>};
>
>struct sigaction {
>
> __sighandler_t sa_handler;
> unsigned long sa_flags;
>
>
>
>
>
> __sigrestore_t sa_restorer;
>
> sigset_t sa_mask;
>};
>
>struct k_sigaction {
> struct sigaction sa;
>
>
>
>};
># 67 "/usr/src/linux-5.14.21-150500.53/include/linux/signal_types.h"
>struct ksignal {
> struct k_sigaction ka;
> kernel_siginfo_t info;
> int sig;
>};
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/syscall_user_dispatch.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/syscall_user_dispatch.h"
>struct syscall_user_dispatch {
> char *selector;
> unsigned long offset;
> unsigned long len;
> bool on_dispatch;
>};
>
>int set_syscall_user_dispatch(unsigned long mode, unsigned long offset,
>         unsigned long len, char *selector);
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/task_io_accounting.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/task_io_accounting.h"
>struct task_io_accounting {
>
>
> u64 rchar;
>
> u64 wchar;
>
> u64 syscr;
>
> u64 syscw;
>
>
>
>
>
>
>
> u64 read_bytes;
>
>
>
>
>
> u64 write_bytes;
># 44 "/usr/src/linux-5.14.21-150500.53/include/linux/task_io_accounting.h"
> u64 cancelled_write_bytes;
>
>};
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/alarmtimer.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/alarmtimer.h"
>struct rtc_device;
>
>enum alarmtimer_type {
> ALARM_REALTIME,
> ALARM_BOOTTIME,
>
>
> ALARM_NUMTYPE,
>
>
> ALARM_REALTIME_FREEZER,
> ALARM_BOOTTIME_FREEZER,
>};
>
>enum alarmtimer_restart {
> ALARMTIMER_NORESTART,
> ALARMTIMER_RESTART,
>};
># 42 "/usr/src/linux-5.14.21-150500.53/include/linux/alarmtimer.h"
>struct alarm {
> struct timerqueue_node node;
> struct hrtimer timer;
> enum alarmtimer_restart (*function)(struct alarm *, ktime_t now);
> enum alarmtimer_type type;
> int state;
> void *data;
>};
>
>void alarm_init(struct alarm *alarm, enum alarmtimer_type type,
>  enum alarmtimer_restart (*function)(struct alarm *, ktime_t));
>void alarm_start(struct alarm *alarm, ktime_t start);
>void alarm_start_relative(struct alarm *alarm, ktime_t start);
>void alarm_restart(struct alarm *alarm);
>int alarm_try_to_cancel(struct alarm *alarm);
>int alarm_cancel(struct alarm *alarm);
>
>u64 alarm_forward(struct alarm *alarm, ktime_t now, ktime_t interval);
>u64 alarm_forward_now(struct alarm *alarm, ktime_t interval);
>ktime_t alarm_expires_remaining(const struct alarm *alarm);
>
>
>
>struct rtc_device *alarmtimer_get_rtcdev(void);
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h" 2
>
>
>struct kernel_siginfo;
>struct task_struct;
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) clockid_t make_process_cpuclock(const unsigned int pid,
>  const clockid_t clock)
>{
> return ((~pid) << 3) | clock;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) clockid_t make_thread_cpuclock(const unsigned int tid,
>  const clockid_t clock)
>{
> return make_process_cpuclock(tid, clock | 4);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) clockid_t fd_to_clockid(const int fd)
>{
> return make_process_cpuclock((unsigned int) fd, 3);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int clockid_to_fd(const clockid_t clk)
>{
> return ~(clk >> 3);
>}
># 69 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h"
>struct cpu_timer {
> struct timerqueue_node node;
> struct timerqueue_head *head;
> struct pid *pid;
> struct list_head elist;
> int firing;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_timer_enqueue(struct timerqueue_head *head,
>         struct cpu_timer *ctmr)
>{
> ctmr->head = head;
> return timerqueue_add(head, &ctmr->node);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_timer_queued(struct cpu_timer *ctmr)
>{
> return !!ctmr->head;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpu_timer_dequeue(struct cpu_timer *ctmr)
>{
> if (cpu_timer_queued(ctmr)) {
>  timerqueue_del(ctmr->head, &ctmr->node);
>  ctmr->head = ((void *)0);
>  return true;
> }
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 cpu_timer_getexpires(struct cpu_timer *ctmr)
>{
> return ctmr->node.expires;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpu_timer_setexpires(struct cpu_timer *ctmr, u64 exp)
>{
> ctmr->node.expires = exp;
>}
>
>
>
>
>
>
>struct posix_cputimer_base {
> u64 nextevt;
> struct timerqueue_head tqhead;
>};
># 129 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h"
>struct posix_cputimers {
> struct posix_cputimer_base bases[3];
> unsigned int timers_active;
> unsigned int expiry_active;
>};
>
>
>
>
>
>
>struct posix_cputimers_work {
> struct callback_head work;
> unsigned int scheduled;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void posix_cputimers_init(struct posix_cputimers *pct)
>{
> memset(pct, 0, sizeof(*pct));
> pct->bases[0].nextevt = ((u64)~0ULL);
> pct->bases[1].nextevt = ((u64)~0ULL);
> pct->bases[2].nextevt = ((u64)~0ULL);
>}
>
>void posix_cputimers_group_init(struct posix_cputimers *pct, u64 cpu_limit);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void posix_cputimers_rt_watchdog(struct posix_cputimers *pct,
>            u64 runtime)
>{
> pct->bases[2].nextevt = runtime;
>}
># 186 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h"
>void clear_posix_cputimers_work(struct task_struct *p);
>void posix_cputimers_init_work(void);
># 218 "/usr/src/linux-5.14.21-150500.53/include/linux/posix-timers.h"
>struct k_itimer {
> struct list_head list;
> struct hlist_node t_hash;
> spinlock_t it_lock;
> const struct k_clock *kclock;
> clockid_t it_clock;
> timer_t it_id;
> int it_active;
> s64 it_overrun;
> s64 it_overrun_last;
> int it_requeue_pending;
> int it_sigev_notify;
> ktime_t it_interval;
> struct signal_struct *it_signal;
> union {
>  struct pid *it_pid;
>  struct task_struct *it_process;
> };
> struct sigqueue *sigq;
> union {
>  struct {
>   struct hrtimer timer;
>  } real;
>  struct cpu_timer cpu;
>  struct {
>   struct alarm alarmtimer;
>  } alarm;
> } it;
> struct callback_head rcu;
>};
>
>void run_posix_cpu_timers(void);
>void posix_cpu_timers_exit(struct task_struct *task);
>void posix_cpu_timers_exit_group(struct task_struct *task);
>void set_process_cpu_timer(struct task_struct *task, unsigned int clock_idx,
>      u64 *newval, u64 *oldval);
>
>void update_rlimit_cpu(struct task_struct *task, unsigned long rlim_new);
>
>void posixtimer_rearm(struct kernel_siginfo *info);
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h"
>enum rseq_cpu_id_state {
> RSEQ_CPU_ID_UNINITIALIZED = -1,
> RSEQ_CPU_ID_REGISTRATION_FAILED = -2,
>};
>
>enum rseq_flags {
> RSEQ_FLAG_UNREGISTER = (1 << 0),
>};
>
>enum rseq_cs_flags_bit {
> RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT = 0,
> RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT = 1,
> RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT = 2,
>};
>
>enum rseq_cs_flags {
> RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT =
>  (1U << RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT),
> RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL =
>  (1U << RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT),
> RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE =
>  (1U << RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT),
>};
>
>
>
>
>
>
>struct rseq_cs {
>
> __u32 version;
>
> __u32 flags;
> __u64 start_ip;
>
> __u64 post_commit_offset;
> __u64 abort_ip;
>} __attribute__((aligned(4 * sizeof(__u64))));
>
>
>
>
>
>
>
>struct rseq {
># 75 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h"
> __u32 cpu_id_start;
># 90 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h"
> __u32 cpu_id;
># 109 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h"
> union {
>  __u64 ptr64;
>
>  __u64 ptr;
># 124 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h"
> } rseq_cs;
># 144 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rseq.h"
> __u32 flags;
>} __attribute__((aligned(4 * sizeof(__u64))));
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kcsan.h" 1
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/kcsan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kcsan_init(void) { }
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
># 1 "./arch/x86/include/generated/asm/kmap_size.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/kmap_size.h" 1
># 1 "./arch/x86/include/generated/asm/kmap_size.h" 2
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h" 2
>
>
>struct audit_context;
>struct backing_dev_info;
>struct bio_list;
>struct blk_plug;
>struct bpf_local_storage;
>struct bpf_run_ctx;
>struct capture_control;
>struct cfs_rq;
>struct fs_struct;
>struct futex_pi_state;
>struct io_context;
>struct io_uring_task;
>struct mempolicy;
>struct nameidata;
>struct nsproxy;
>struct perf_event_context;
>struct pid_namespace;
>struct pipe_inode_info;
>struct rcu_node;
>struct reclaim_state;
>struct robust_list_head;
>struct root_domain;
>struct rq;
>struct sched_attr;
>struct sched_param;
>struct seq_file;
>struct sighand_struct;
>struct signal_struct;
>struct task_delay_info;
>struct task_group;
># 280 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern void scheduler_tick(void);
>
>
>
>extern long schedule_timeout(long timeout);
>extern long schedule_timeout_interruptible(long timeout);
>extern long schedule_timeout_killable(long timeout);
>extern long schedule_timeout_uninterruptible(long timeout);
>extern long schedule_timeout_idle(long timeout);
> void schedule(void);
>extern void schedule_preempt_disabled(void);
> void preempt_schedule_irq(void);
>
>
>
>
>extern int __attribute__((__warn_unused_result__)) io_schedule_prepare(void);
>extern void io_schedule_finish(int token);
>extern long io_schedule_timeout(long timeout);
>extern void io_schedule(void);
># 310 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>struct prev_cputime {
>
> u64 utime;
> u64 stime;
> raw_spinlock_t lock;
>
>};
>
>enum vtime_state {
>
> VTIME_INACTIVE = 0,
>
> VTIME_IDLE,
>
> VTIME_SYS,
>
> VTIME_USER,
>
> VTIME_GUEST,
>};
>
>struct vtime {
> seqcount_t seqcount;
> unsigned long long starttime;
> enum vtime_state state;
> unsigned int cpu;
> u64 utime;
> u64 stime;
> u64 gtime;
>};
>
>
>
>
>
>
>
>enum uclamp_id {
> UCLAMP_MIN = 0,
> UCLAMP_MAX,
> UCLAMP_CNT
>};
>
>
>extern struct root_domain def_root_domain;
>extern struct mutex sched_domains_mutex;
>
>
>struct sched_info {
>
>
>
>
> unsigned long pcount;
>
>
> unsigned long long run_delay;
>
>
>
>
> unsigned long long last_arrival;
>
>
> unsigned long long last_queued;
>
>
>};
># 393 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>struct load_weight {
> unsigned long weight;
> u32 inv_weight;
>};
># 427 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>struct util_est {
> unsigned int enqueued;
> unsigned int ewma;
>
>
>} __attribute__((__aligned__(sizeof(u64))));
># 479 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>struct sched_avg {
> u64 last_update_time;
> u64 load_sum;
> u64 runnable_sum;
> u32 util_sum;
> u32 period_contrib;
> unsigned long load_avg;
> unsigned long runnable_avg;
> unsigned long util_avg;
> struct util_est util_est;
>} __attribute__((__aligned__((1 << (6)))));
>
>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;
>
>
> u64 core_forceidle_sum;
>
>
>} __attribute__((__aligned__((1 << (6)))));
>
>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;
>
>
> int depth;
> struct sched_entity *parent;
>
> struct cfs_rq *cfs_rq;
>
> struct cfs_rq *my_q;
>
> unsigned long runnable_weight;
># 563 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> struct sched_avg avg;
>
>};
>
>struct sched_rt_entity {
> struct list_head run_list;
> unsigned long timeout;
> unsigned long watchdog_stamp;
> unsigned int time_slice;
> unsigned short on_rq;
> unsigned short on_list;
>
> struct sched_rt_entity *back;
>
>
>
>
>
>
>
> void *suse_kabi_padding;
>} __attribute__((__designated_init__));
>
>struct sched_dl_entity {
> struct rb_node rb_node;
>
>
>
>
>
>
> u64 dl_runtime;
> u64 dl_deadline;
> u64 dl_period;
> u64 dl_bw;
> u64 dl_density;
>
>
>
>
>
>
> s64 runtime;
> u64 deadline;
> unsigned int flags;
># 633 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> unsigned int dl_throttled : 1;
> unsigned int dl_yielded : 1;
> unsigned int dl_non_contending : 1;
> unsigned int dl_overrun : 1;
>
>
>
>
>
> struct hrtimer dl_timer;
># 651 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> struct hrtimer inactive_timer;
>
>
>
>
>
>
>
> struct sched_dl_entity *pi_se;
>
>};
># 698 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>union rcu_special {
> struct {
>  u8 blocked;
>  u8 need_qs;
>  u8 exp_hint;
>  u8 need_mb;
> } b;
> u32 s;
>};
>
>enum perf_event_task_context {
> perf_invalid_context = -1,
> perf_hw_context = 0,
> perf_sw_context,
> perf_nr_task_contexts,
>};
>
>struct wake_q_node {
> struct wake_q_node *next;
>};
>
>struct kmap_ctrl {
>
>
>
>
>};
>
>struct task_struct {
>
>
>
>
>
> struct thread_info thread_info;
>
> unsigned int __state;
># 745 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>
>
> void *stack;
> refcount_t usage;
>
> unsigned int flags;
> unsigned int ptrace;
>
>
> int on_cpu;
> struct __call_single_node wake_entry;
>
>
> unsigned int cpu;
>
> unsigned int wakee_flips;
> unsigned long wakee_flip_decay_ts;
> struct task_struct *last_wakee;
># 771 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> int recent_used_cpu;
> int wake_cpu;
>
> int on_rq;
>
> int prio;
> int static_prio;
> int normal_prio;
> unsigned int rt_priority;
>
> struct sched_entity se;
> struct sched_rt_entity rt;
> struct sched_dl_entity dl;
> const struct sched_class *sched_class;
>
>
> struct rb_node core_node;
> unsigned long core_cookie;
> unsigned int core_occupation;
>
>
>
> struct task_group *sched_task_group;
># 809 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> struct sched_statistics stats;
>
>
>
> struct hlist_head preempt_notifiers;
>
>
>
> unsigned int btrace_seq;
>
>
> unsigned int policy;
> int nr_cpus_allowed;
> const cpumask_t *cpus_ptr;
> cpumask_t cpus_mask;
> void *migration_pending;
>
> unsigned short migration_disabled;
>
> unsigned short migration_flags;
>
>
> int rcu_read_lock_nesting;
> union rcu_special rcu_read_unlock_special;
> struct list_head rcu_node_entry;
> struct rcu_node *rcu_blocked_node;
>
>
>
> unsigned long rcu_tasks_nvcsw;
> u8 rcu_tasks_holdout;
> u8 rcu_tasks_idx;
> int rcu_tasks_idle_cpu;
> struct list_head rcu_tasks_holdout_list;
>
>
>
> int trc_reader_nesting;
> int trc_ipi_to_cpu;
> union rcu_special trc_reader_special;
> bool trc_reader_checked;
> struct list_head trc_holdout_list;
>
>
> struct sched_info sched_info;
>
> struct list_head tasks;
>
> struct plist_node pushable_tasks;
> struct rb_node pushable_dl_tasks;
>
>
> struct mm_struct *mm;
> struct mm_struct *active_mm;
>
>
> struct vmacache vmacache;
>
>
> struct task_rss_stat rss_stat;
>
> int exit_state;
> int exit_code;
> int exit_signal;
>
> int pdeath_signal;
>
> unsigned long jobctl;
>
>
> unsigned int personality;
>
>
> unsigned sched_reset_on_fork:1;
> unsigned sched_contributes_to_load:1;
> unsigned sched_migrated:1;
>
> unsigned sched_psi_wake_requeue:1;
>
>
>
> unsigned :0;
># 907 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> unsigned sched_remote_wakeup:1;
>
>
> unsigned in_execve:1;
> unsigned in_iowait:1;
>
> unsigned restore_sigmask:1;
>
>
> unsigned in_user_fault:1;
>
>
>
>
>
>
> unsigned no_cgroup_migration:1;
>
> unsigned frozen:1;
>
>
> unsigned use_memdelay:1;
>
>
>
> unsigned in_memstall:1;
>
>
>
> unsigned in_page_owner:1;
>
>
>
> unsigned in_eventfd_signal:1;
>
>
> unsigned pasid_activated:1;
>
>
> unsigned long atomic_flags;
>
> struct restart_block restart_block;
>
> pid_t pid;
> pid_t tgid;
>
>
>
> unsigned long stack_canary;
># 964 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> struct task_struct *real_parent;
>
>
> struct task_struct *parent;
>
>
>
>
> struct list_head children;
> struct list_head sibling;
> struct task_struct *group_leader;
>
>
>
>
>
>
>
> struct list_head ptraced;
> struct list_head ptrace_entry;
>
>
> struct pid *thread_pid;
> struct hlist_node pid_links[PIDTYPE_MAX];
> struct list_head thread_group;
> struct list_head thread_node;
>
> struct completion *vfork_done;
>
>
> int *set_child_tid;
>
>
> int *clear_child_tid;
>
>
> void *pf_io_worker;
>
> u64 utime;
> u64 stime;
>
>
>
>
> u64 gtime;
> struct prev_cputime prev_cputime;
>
> struct vtime vtime;
>
>
>
> atomic_t tick_dep_mask;
>
>
> unsigned long nvcsw;
> unsigned long nivcsw;
>
>
> u64 start_time;
>
>
> u64 start_boottime;
>
>
> unsigned long min_flt;
> unsigned long maj_flt;
>
>
> struct posix_cputimers posix_cputimers;
>
>
> struct posix_cputimers_work posix_cputimers_work;
>
>
>
>
>
> const struct cred *ptracer_cred;
>
>
> const struct cred *real_cred;
>
>
> const struct cred *cred;
>
>
>
> struct key *cached_requested_key;
># 1061 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> char comm[16];
>
> struct nameidata *nameidata;
>
>
> struct sysv_sem sysvsem;
> struct sysv_shm sysvshm;
>
>
> unsigned long last_switch_count;
> unsigned long last_switch_time;
>
>
> struct fs_struct *fs;
>
>
> struct files_struct *files;
>
>
> struct io_uring_task *io_uring;
>
>
>
> struct nsproxy *nsproxy;
>
>
> struct signal_struct *signal;
> struct sighand_struct *sighand;
> sigset_t blocked;
> sigset_t real_blocked;
>
> sigset_t saved_sigmask;
> struct sigpending pending;
> unsigned long sas_ss_sp;
> size_t sas_ss_size;
> unsigned int sas_ss_flags;
>
> struct callback_head *task_works;
>
>
>
> struct audit_context *audit_context;
>
> kuid_t loginuid;
> unsigned int sessionid;
>
> struct seccomp seccomp;
> struct syscall_user_dispatch syscall_dispatch;
>
>
> u64 parent_exec_id;
> u64 self_exec_id;
>
>
> spinlock_t alloc_lock;
>
>
> raw_spinlock_t pi_lock;
>
> struct wake_q_node wake_q;
>
>
>
> struct rb_root_cached pi_waiters;
>
> struct task_struct *pi_top_task;
>
> struct rt_mutex_waiter *pi_blocked_on;
># 1165 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> 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;
>
>
> struct capture_control *capture_control;
>
>
> unsigned long ptrace_message;
> kernel_siginfo_t *last_siginfo;
>
> struct task_io_accounting ioac;
>
>
> unsigned int psi_flags;
>
>
>
> u64 acct_rss_mem1;
>
> u64 acct_vm_mem1;
>
> u64 acct_timexpd;
>
>
>
> nodemask_t mems_allowed;
>
> seqcount_spinlock_t mems_allowed_seq;
> int cpuset_mem_spread_rotor;
> int cpuset_slab_spread_rotor;
>
>
>
> struct css_set *cgroups;
>
> struct list_head cg_list;
>
>
> u32 closid;
> u32 rmid;
>
>
> struct robust_list_head *robust_list;
>
> struct compat_robust_list_head *compat_robust_list;
>
> struct list_head pi_state_list;
> struct futex_pi_state *pi_state_cache;
> struct mutex futex_exit_mutex;
> unsigned int futex_state;
>
>
> struct perf_event_context *perf_event_ctxp[perf_nr_task_contexts];
> struct mutex perf_event_mutex;
> struct list_head perf_event_list;
>
>
>
>
>
>
> struct mempolicy *mempolicy;
> short il_prev;
> short pref_node_fork;
>
>
> int numa_scan_seq;
> unsigned int numa_scan_period;
> unsigned int numa_scan_period_max;
> int numa_preferred_nid;
> unsigned long numa_migrate_retry;
>
> u64 node_stamp;
> u64 last_task_numa_placement;
> u64 last_sum_exec_runtime;
> struct callback_head numa_work;
># 1262 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> struct numa_group *numa_group;
># 1278 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> unsigned long *numa_faults;
> unsigned long total_numa_faults;
>
>
>
>
>
>
>
> unsigned long numa_faults_locality[3];
>
> unsigned long numa_pages_migrated;
>
>
>
> struct rseq *rseq;
> u32 rseq_sig;
>
>
>
>
> unsigned long rseq_event_mask;
>
>
> struct tlbflush_unmap_batch tlb_ubc;
>
> union {
>  refcount_t rcu_users;
>  struct callback_head rcu;
> };
>
>
> struct pipe_inode_info *splice_pipe;
>
> struct page_frag task_frag;
>
>
> struct task_delay_info *delays;
>
>
>
> int make_it_fail;
> unsigned int fail_nth;
>
>
>
>
>
> int nr_dirtied;
> int nr_dirtied_pause;
>
> unsigned long dirty_paused_when;
>
>
> int latency_record_count;
> struct latency_record latency_record[32];
>
>
>
>
>
> u64 timer_slack_ns;
> u64 default_timer_slack_ns;
># 1359 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> int curr_ret_stack;
> int curr_ret_depth;
>
>
> struct ftrace_ret_stack *ret_stack;
>
>
> unsigned long long ftrace_timestamp;
>
>
>
>
>
> atomic_t trace_overrun;
>
>
> atomic_t tracing_graph_pause;
>
>
>
>
> unsigned long trace;
>
>
> unsigned long trace_recursion;
># 1412 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> struct mem_cgroup *memcg_in_oom;
> gfp_t memcg_oom_gfp_mask;
> int memcg_oom_order;
>
>
> unsigned int memcg_nr_pages_over_high;
>
>
> struct mem_cgroup *active_memcg;
>
>
>
> struct request_queue *throttle_queue;
>
>
>
> struct uprobe_task *utask;
>
>
> unsigned int sequential_io;
> unsigned int sequential_io_avg;
>
> struct kmap_ctrl kmap_ctrl;
>
>
>
>
>
>
> int pagefault_disabled;
>
> struct task_struct *oom_reaper_list;
>
>
> struct vm_struct *stack_vm_area;
>
>
>
> refcount_t stack_refcount;
>
>
> int patch_state;
>
>
>
> void *security;
>
>
>
> struct bpf_local_storage *bpf_storage;
>
> struct bpf_run_ctx *bpf_ctx;
># 1472 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
> void *mce_vaddr;
> __u64 mce_kflags;
> u64 mce_addr;
> __u64 mce_ripv : 1,
>     mce_whole_page : 1,
>     __mce_reserved : 62;
> struct callback_head mce_kill_me;
> int mce_count;
>
>
>
> struct llist_head kretprobe_instances;
>
>
> struct llist_head rethooks;
>
>
> void *suse_kabi_padding;
>
>
>
>
>
>
>
>
> struct thread_struct thread;
>
>
>
>
>
>
>
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid *task_pid(struct task_struct *task)
>{
> return task->thread_pid;
>}
># 1524 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>pid_t __task_pid_nr_ns(struct task_struct *task, enum pid_type type, struct pid_namespace *ns);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_pid_nr(struct task_struct *tsk)
>{
> return tsk->pid;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_pid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_PID, ns);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_pid_vnr(struct task_struct *tsk)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_PID, ((void *)0));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_tgid_nr(struct task_struct *tsk)
>{
> return tsk->tgid;
>}
># 1557 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pid_alive(const struct task_struct *p)
>{
> return p->thread_pid != ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_pgrp_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ns);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_pgrp_vnr(struct task_struct *tsk)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_PGID, ((void *)0));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_session_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_SID, ns);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_session_vnr(struct task_struct *tsk)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_SID, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_tgid_nr_ns(struct task_struct *tsk, struct pid_namespace *ns)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_TGID, ns);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_tgid_vnr(struct task_struct *tsk)
>{
> return __task_pid_nr_ns(tsk, PIDTYPE_TGID, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_ppid_nr_ns(const struct task_struct *tsk, struct pid_namespace *ns)
>{
> pid_t pid = 0;
>
> rcu_read_lock();
> if (pid_alive(tsk))
>  pid = task_tgid_nr_ns(({ typeof(*(tsk->real_parent)) *________p1 = (typeof(*(tsk->real_parent)) *)({ do { extern void __compiletime_assert_165(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((tsk->real_parent)) == sizeof(char) || sizeof((tsk->real_parent)) == sizeof(short) || sizeof((tsk->real_parent)) == sizeof(int) || sizeof((tsk->real_parent)) == sizeof(long)) || sizeof((tsk->real_parent)) == sizeof(long long))) __compiletime_assert_165(); } while (0); (*(const volatile typeof( _Generic(((tsk->real_parent)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((tsk->real_parent)))) *)&((tsk->real_parent))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(tsk->real_parent)) *)(________p1)); }), ns);
> rcu_read_unlock();
>
> return pid;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_ppid_nr(const struct task_struct *tsk)
>{
> return task_ppid_nr_ns(tsk, &init_pid_ns);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pid_t task_pgrp_nr(struct task_struct *tsk)
>{
> return task_pgrp_nr_ns(tsk, &init_pid_ns);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int task_state_index(struct task_struct *tsk)
>{
> unsigned int tsk_state = ({ do { extern void __compiletime_assert_166(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(tsk->__state) == sizeof(char) || sizeof(tsk->__state) == sizeof(short) || sizeof(tsk->__state) == sizeof(int) || sizeof(tsk->__state) == sizeof(long)) || sizeof(tsk->__state) == sizeof(long long))) __compiletime_assert_166(); } while (0); (*(const volatile typeof( _Generic((tsk->__state), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (tsk->__state))) *)&(tsk->__state)); });
> unsigned int state = (tsk_state | tsk->exit_state) & (0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040);
>
> do { extern void __compiletime_assert_167(void) __attribute__((__error__("BUILD_BUG_ON failed: " "((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) == 0 || ((((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) & (((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) - 1)) != 0)"))); if (!(!(((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) == 0 || ((((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) & (((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) - 1)) != 0)))) __compiletime_assert_167(); } while (0);
>
> if (tsk_state == (0x0002 | 0x0400))
>  state = ((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1);
>
> return fls(state);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) char task_index_to_char(unsigned int state)
>{
> static const char state_char[] = "RSDTtXZPI";
>
> do { extern void __compiletime_assert_168(void) __attribute__((__error__("BUILD_BUG_ON failed: " "1 + ilog2(TASK_REPORT_MAX) != sizeof(state_char) - 1"))); if (!(!(1 + ( __builtin_constant_p((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) ? (((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) < 2 ? 0 : 63 - __builtin_clzll((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1))) : (sizeof((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) <= 4) ? __ilog2_u32((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) : __ilog2_u64((((0x0000 | 0x0001 | 0x0002 | 0x0004 | 0x0008 | 0x0010 | 0x0020 | 0x0040) + 1) << 1)) ) != sizeof(state_char) - 1))) __compiletime_assert_168(); } while (0);
>
> return state_char[state];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) char task_state_to_char(struct task_struct *tsk)
>{
> return task_index_to_char(task_state_index(tsk));
>}
># 1655 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_global_init(struct task_struct *tsk)
>{
> return task_tgid_nr(tsk) == 1;
>}
>
>extern struct pid *cad_pid;
># 1722 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool is_percpu_thread(void)
>{
>
> return (get_current()->flags & 0x04000000) &&
>  (get_current()->nr_cpus_allowed == 1);
>
>
>
>}
># 1754 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_no_new_privs(struct task_struct *p) { return test_bit(0, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_no_new_privs(struct task_struct *p) { set_bit(0, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spread_page(struct task_struct *p) { return test_bit(1, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spread_page(struct task_struct *p) { set_bit(1, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_clear_spread_page(struct task_struct *p) { clear_bit(1, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spread_slab(struct task_struct *p) { return test_bit(2, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spread_slab(struct task_struct *p) { set_bit(2, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_clear_spread_slab(struct task_struct *p) { clear_bit(2, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spec_ssb_disable(struct task_struct *p) { return test_bit(3, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spec_ssb_disable(struct task_struct *p) { set_bit(3, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_clear_spec_ssb_disable(struct task_struct *p) { clear_bit(3, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spec_ssb_noexec(struct task_struct *p) { return test_bit(7, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spec_ssb_noexec(struct task_struct *p) { set_bit(7, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_clear_spec_ssb_noexec(struct task_struct *p) { clear_bit(7, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spec_ssb_force_disable(struct task_struct *p) { return test_bit(4, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spec_ssb_force_disable(struct task_struct *p) { set_bit(4, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spec_ib_disable(struct task_struct *p) { return test_bit(5, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spec_ib_disable(struct task_struct *p) { set_bit(5, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_clear_spec_ib_disable(struct task_struct *p) { clear_bit(5, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_spec_ib_force_disable(struct task_struct *p) { return test_bit(6, &p->atomic_flags); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_set_spec_ib_force_disable(struct task_struct *p) { set_bit(6, &p->atomic_flags); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>current_restore_flags(unsigned long orig_flags, unsigned long flags)
>{
> get_current()->flags &= ~flags;
> get_current()->flags |= orig_flags & flags;
>}
>
>extern int cpuset_cpumask_can_shrink(const struct cpumask *cur, const struct cpumask *trial);
>extern int task_can_attach(struct task_struct *p, const struct cpumask *cs_cpus_allowed);
>
>extern void do_set_cpus_allowed(struct task_struct *p, const struct cpumask *new_mask);
>extern int set_cpus_allowed_ptr(struct task_struct *p, const struct cpumask *new_mask);
># 1807 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern int yield_to(struct task_struct *p, bool preempt);
>extern void set_user_nice(struct task_struct *p, long nice);
>extern int task_prio(const struct task_struct *p);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int task_nice(const struct task_struct *p)
>{
> return (((p)->static_prio) - (100 + (19 - -20 + 1) / 2));
>}
>
>extern int can_nice(const struct task_struct *p, const int nice);
>extern int task_curr(const struct task_struct *p);
>extern int idle_cpu(int cpu);
>extern int available_idle_cpu(int cpu);
>extern int sched_setscheduler(struct task_struct *, int, const struct sched_param *);
>extern int sched_setscheduler_nocheck(struct task_struct *, int, const struct sched_param *);
>extern void sched_set_fifo(struct task_struct *p);
>extern void sched_set_fifo_low(struct task_struct *p);
>extern void sched_set_normal(struct task_struct *p, int nice);
>extern int sched_setattr(struct task_struct *, const struct sched_attr *);
>extern int sched_setattr_nocheck(struct task_struct *, const struct sched_attr *);
>extern struct task_struct *idle_task(int cpu);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool is_idle_task(const struct task_struct *p)
>{
> return !!(p->flags & 0x00000002);
>}
>
>extern struct task_struct *curr_task(int cpu);
>extern void ia64_set_curr_task(int cpu, struct task_struct *p);
>
>void yield(void);
>
>union thread_union {
>
> struct task_struct task;
>
>
>
>
> unsigned long stack[(((1UL) << 12) << (2 + 0))/sizeof(long)];
>};
>
>
>
>
>
>extern unsigned long init_stack[(((1UL) << 12) << (2 + 0)) / sizeof(unsigned long)];
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct thread_info *task_thread_info(struct task_struct *task)
>{
> return &task->thread_info;
>}
># 1887 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern struct task_struct *find_task_by_vpid(pid_t nr);
>extern struct task_struct *find_task_by_pid_ns(pid_t nr, struct pid_namespace *ns);
>
>
>
>
>extern struct task_struct *find_get_task_by_vpid(pid_t nr);
>
>extern int wake_up_state(struct task_struct *tsk, unsigned int state);
>extern int wake_up_process(struct task_struct *tsk);
>extern void wake_up_new_task(struct task_struct *tsk);
>
>
>extern void kick_process(struct task_struct *tsk);
>
>
>
>
>extern void __set_task_comm(struct task_struct *tsk, const char *from, bool exec);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_task_comm(struct task_struct *tsk, const char *from)
>{
> __set_task_comm(tsk, from, false);
>}
>
>extern char *__get_task_comm(char *to, size_t len, struct task_struct *tsk);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void scheduler_ipi(void)
>{
>
>
>
>
>
> do { if (test_ti_thread_flag(((struct thread_info *)get_current()), 3)) set_preempt_need_resched(); } while (0);
>}
>extern unsigned long wait_task_inactive(struct task_struct *, unsigned int match_state);
># 1941 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> set_ti_thread_flag(task_thread_info(tsk), flag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> clear_ti_thread_flag(task_thread_info(tsk), flag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_tsk_thread_flag(struct task_struct *tsk, int flag,
>       bool value)
>{
> update_ti_thread_flag(task_thread_info(tsk), flag, value);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_and_set_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_and_set_ti_thread_flag(task_thread_info(tsk), flag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_and_clear_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_and_clear_ti_thread_flag(task_thread_info(tsk), flag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_tsk_thread_flag(struct task_struct *tsk, int flag)
>{
> return test_ti_thread_flag(task_thread_info(tsk), flag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_tsk_need_resched(struct task_struct *tsk)
>{
> set_tsk_thread_flag(tsk,3);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_tsk_need_resched(struct task_struct *tsk)
>{
> clear_tsk_thread_flag(tsk,3);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_tsk_need_resched(struct task_struct *tsk)
>{
> return __builtin_expect(!!(test_tsk_thread_flag(tsk,3)), 0);
>}
># 1994 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern int __cond_resched(void);
>
>
>
>extern struct static_call_key __SCK__cond_resched; extern struct static_call_tramp __SCT__cond_resched; extern typeof(__cond_resched) __SCtype__cond_resched;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int _cond_resched(void)
>{
> return ((typeof(&__SCtype__cond_resched))&__SCT__cond_resched)();
>}
># 2025 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern int __cond_resched_lock(spinlock_t *lock);
>extern int __cond_resched_rwlock_read(rwlock_t *lock);
>extern int __cond_resched_rwlock_write(rwlock_t *lock);
># 2063 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cond_resched_rcu(void)
>{
>
>
>
>
>
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int spin_needbreak(spinlock_t *lock)
>{
>
> return spin_is_contended(lock);
>
>
>
>}
># 2094 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rwlock_needbreak(rwlock_t *lock)
>{
>
> return queued_rwlock_is_contended(&(lock)->raw_lock);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool need_resched(void)
>{
> return __builtin_expect(!!(test_ti_thread_flag(((struct thread_info *)get_current()), 3)), 0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int task_cpu(const struct task_struct *p)
>{
>
> return ({ do { extern void __compiletime_assert_169(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(p->cpu) == sizeof(char) || sizeof(p->cpu) == sizeof(short) || sizeof(p->cpu) == sizeof(int) || sizeof(p->cpu) == sizeof(long)) || sizeof(p->cpu) == sizeof(long long))) __compiletime_assert_169(); } while (0); (*(const volatile typeof( _Generic((p->cpu), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (p->cpu))) *)&(p->cpu)); });
>
>
>
>}
>
>extern void set_task_cpu(struct task_struct *p, unsigned int cpu);
># 2137 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern bool sched_task_on_rq(struct task_struct *p);
>extern unsigned long get_wchan(struct task_struct *p);
># 2155 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>extern long sched_setaffinity(pid_t pid, const struct cpumask *new_mask);
>extern long sched_getaffinity(pid_t pid, struct cpumask *mask);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool owner_on_cpu(struct task_struct *owner)
>{
>
>
>
>
> return owner->on_cpu && !vcpu_is_preempted(task_cpu(owner));
>}
>
>
>unsigned long sched_cpu_util(int cpu, unsigned long max);
># 2182 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>enum rseq_event_mask_bits {
> RSEQ_EVENT_PREEMPT_BIT = RSEQ_CS_FLAG_NO_RESTART_ON_PREEMPT_BIT,
> RSEQ_EVENT_SIGNAL_BIT = RSEQ_CS_FLAG_NO_RESTART_ON_SIGNAL_BIT,
> RSEQ_EVENT_MIGRATE_BIT = RSEQ_CS_FLAG_NO_RESTART_ON_MIGRATE_BIT,
>};
>
>enum rseq_event_mask {
> RSEQ_EVENT_PREEMPT = (1U << RSEQ_EVENT_PREEMPT_BIT),
> RSEQ_EVENT_SIGNAL = (1U << RSEQ_EVENT_SIGNAL_BIT),
> RSEQ_EVENT_MIGRATE = (1U << RSEQ_EVENT_MIGRATE_BIT),
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_set_notify_resume(struct task_struct *t)
>{
> if (t->rseq)
>  set_tsk_thread_flag(t, 1);
>}
>
>void __rseq_handle_notify_resume(struct ksignal *sig, struct pt_regs *regs);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_handle_notify_resume(struct ksignal *ksig,
>          struct pt_regs *regs)
>{
> if (get_current()->rseq)
>  __rseq_handle_notify_resume(ksig, regs);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_signal_deliver(struct ksignal *ksig,
>           struct pt_regs *regs)
>{
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> __set_bit(RSEQ_EVENT_SIGNAL_BIT, &get_current()->rseq_event_mask);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
> rseq_handle_notify_resume(ksig, regs);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_preempt(struct task_struct *t)
>{
> __set_bit(RSEQ_EVENT_PREEMPT_BIT, &t->rseq_event_mask);
> rseq_set_notify_resume(t);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_migrate(struct task_struct *t)
>{
> __set_bit(RSEQ_EVENT_MIGRATE_BIT, &t->rseq_event_mask);
> rseq_set_notify_resume(t);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_fork(struct task_struct *t, unsigned long clone_flags)
>{
> if (clone_flags & 0x00000100) {
>  t->rseq = ((void *)0);
>  t->rseq_sig = 0;
>  t->rseq_event_mask = 0;
> } else {
>  t->rseq = get_current()->rseq;
>  t->rseq_sig = get_current()->rseq_sig;
>  t->rseq_event_mask = get_current()->rseq_event_mask;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_execve(struct task_struct *t)
>{
> t->rseq = ((void *)0);
> t->rseq_sig = 0;
> t->rseq_event_mask = 0;
>}
># 2290 "/usr/src/linux-5.14.21-150500.53/include/linux/sched.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rseq_syscall(struct pt_regs *regs)
>{
>}
>
>
>
>const struct sched_avg *sched_trace_cfs_rq_avg(struct cfs_rq *cfs_rq);
>char *sched_trace_cfs_rq_path(struct cfs_rq *cfs_rq, char *str, int len);
>int sched_trace_cfs_rq_cpu(struct cfs_rq *cfs_rq);
>
>const struct sched_avg *sched_trace_rq_avg_rt(struct rq *rq);
>const struct sched_avg *sched_trace_rq_avg_dl(struct rq *rq);
>const struct sched_avg *sched_trace_rq_avg_irq(struct rq *rq);
>
>int sched_trace_rq_cpu(struct rq *rq);
>int sched_trace_rq_cpu_capacity(struct rq *rq);
>int sched_trace_rq_nr_running(struct rq *rq);
>
>const struct cpumask *sched_trace_rd_span(struct root_domain *rd);
>
>
>extern void sched_core_free(struct task_struct *tsk);
>extern void sched_core_fork(struct task_struct *p);
>extern int sched_core_share_pid(unsigned int cmd, pid_t pid, enum pid_type type,
>    unsigned long uaddr);
># 29 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pkru.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pkru.h"
>extern u32 init_pkru_value;
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __pkru_allows_read(u32 pkru, u16 pkey)
>{
> int pkru_pkey_bits = pkey * 2;
> return !(pkru & (0x1u << pkru_pkey_bits));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __pkru_allows_write(u32 pkru, u16 pkey)
>{
> int pkru_pkey_bits = pkey * 2;
>
>
>
>
> return !(pkru & ((0x1u|0x2u) << pkru_pkey_bits));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 read_pkru(void)
>{
> if ((__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & (0|0) )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & (0|0|0|0| 0) )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+ 4), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+ 4), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+ 4)) )))
>  return rdpkru();
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void write_pkru(u32 pkru)
>{
> if (!(__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & (0|0) )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & (0|0|0|0| 0) )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+ 4), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+ 4), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+ 4)) )))
>  return;
>
>
>
>
> if (pkru != rdpkru())
>  wrpkru(pkru);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pkru_write_default(void)
>{
> if (!(__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & (0|0) )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & (0|0|0|0| 0) )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+ 4), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+ 4)) && ( ((((16*32+ 4))>>5)==(0) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+ 4))>>5)==(1) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+ 4))>>5)==(2) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(3) && (1UL<<(((16*32+ 4))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+ 4))>>5)==(4) && (1UL<<(((16*32+ 4))&31) & (0) )) || ((((16*32+ 4))>>5)==(5) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(6) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(7) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(8) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(9) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(10) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(11) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(12) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(13) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(14) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(15) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(16) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(17) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(18) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((((16*32+ 4))>>5)==(19) && (1UL<<(((16*32+ 4))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+ 4), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+ 4)) )))
>  return;
>
> wrpkru(({ do { extern void __compiletime_assert_170(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(init_pkru_value) == sizeof(char) || sizeof(init_pkru_value) == sizeof(short) || sizeof(init_pkru_value) == sizeof(int) || sizeof(init_pkru_value) == sizeof(long)) || sizeof(init_pkru_value) == sizeof(long long))) __compiletime_assert_170(); } while (0); (*(const volatile typeof( _Generic((init_pkru_value), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (init_pkru_value))) *)&(init_pkru_value)); }));
>}
># 21 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/api.h" 1
># 29 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/api.h"
>extern void kernel_fpu_begin_mask(unsigned int kfpu_mask);
>extern void kernel_fpu_end(void);
>extern bool irq_fpu_usable(void);
>extern void fpregs_mark_activate(void);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kernel_fpu_begin(void)
>{
>
>
>
>
>
> kernel_fpu_begin_mask((((1UL)) << (1)));
>
>
>
>
>
>
>
>}
># 69 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/api.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fpregs_lock(void)
>{
> if (!0)
>  local_bh_disable();
> else
>  do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fpregs_unlock(void)
>{
> if (!0)
>  local_bh_enable();
> else
>  do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fpregs_assert_state_consistent(void) { }
>
>
>
>
>
>extern void switch_fpu_return(void);
># 103 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/api.h"
>extern int cpu_has_xfeatures(u64 xfeatures_mask, const char **feature_name);
># 112 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fpu/api.h"
>extern int fpu__exception_code(struct fpu *fpu, int trap_nr);
>extern void fpu_sync_fpstate(struct fpu *fpu);
>extern void fpu_reset_from_exception_fixup(void);
>
>
>extern void fpu__init_cpu(void);
>extern void fpu__init_system(struct cpuinfo_x86 *c);
>extern void fpu__init_check_bugs(void);
>extern void fpu__resume_cpu(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fpstate_init_soft(struct swregs_state *soft) {}
>
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_fpu_fpregs_owner_ctx; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct fpu *) fpu_fpregs_owner_ctx;
>
>
>
>extern void fpstate_free(struct fpu *fpu);
>
>
>
>
>
>extern void fpstate_clear_xstate_component(struct fpstate *fps, unsigned int xfeature);
>
>
>extern bool fpu_alloc_guest_fpstate(struct fpu_guest *gfpu);
>extern void fpu_free_guest_fpstate(struct fpu_guest *gfpu);
>extern int fpu_swap_kvm_fpstate(struct fpu_guest *gfpu, bool enter_guest);
>
>extern void fpu_copy_guest_fpstate_to_uabi(struct fpu_guest *gfpu, void *buf, unsigned int size, u32 pkru);
>extern int fpu_copy_uabi_to_guest_fpstate(struct fpu_guest *gfpu, const void *buf, u64 xcr0, u32 *vpkru);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fpstate_set_confidential(struct fpu_guest *gfpu)
>{
> gfpu->fpstate->is_confidential = true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fpstate_is_confidential(struct fpu_guest *gfpu)
>{
> return gfpu->fpstate->is_confidential;
>}
>
>
>struct task_struct;
>extern long fpu_xstate_prctl(struct task_struct *tsk, int option, unsigned long arg2);
>
>extern void fpu_idle_fpregs(void);
># 22 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/coco.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/coco.h" 2
>
>enum cc_vendor {
> CC_VENDOR_NONE,
> CC_VENDOR_AMD,
> CC_VENDOR_HYPERV,
> CC_VENDOR_INTEL,
>};
>
>void cc_set_vendor(enum cc_vendor v);
>void cc_set_mask(u64 mask);
>
>
>u64 cc_mkenc(u64 val);
>u64 cc_mkdec(u64 val);
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/pgtable_uffd.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h" 2
>
>extern pgd_t early_top_pgt[512];
>bool __attribute__((__section__(".init.text"))) __attribute__((__cold__)) __early_make_pgtable(unsigned long address, pmdval_t pmd);
>
>void ptdump_walk_pgd_level(struct seq_file *m, struct mm_struct *mm);
>void ptdump_walk_pgd_level_debugfs(struct seq_file *m, struct mm_struct *mm,
>       bool user);
>void ptdump_walk_pgd_level_checkwx(void);
>void ptdump_walk_user_pgd_level_checkwx(void);
># 52 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>extern unsigned long empty_zero_page[((1UL) << 12) / sizeof(unsigned long)]
> __attribute__((__externally_visible__));
>
>
>extern spinlock_t pgd_lock;
>extern struct list_head pgd_list;
>
>extern struct mm_struct *pgd_page_get_mm(struct page *page);
>
>extern pmdval_t early_pmd_flags;
># 125 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_dirty(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 6);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_young(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_dirty(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 6);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_young(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_dirty(pud_t pud)
>{
> return pud_flags(pud) & (((pteval_t)(1)) << 6);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_young(pud_t pud)
>{
> return pud_flags(pud) & (((pteval_t)(1)) << 5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_write(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_huge(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 7);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_global(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 8);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_exec(pte_t pte)
>{
> return !(pte_flags(pte) & (((pteval_t)(1)) << 63));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_special(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 9);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 protnone_mask(u64 val);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pte_pfn(pte_t pte)
>{
> phys_addr_t pfn = pte_val(pte);
> pfn ^= protnone_mask(pfn);
> return (pfn & ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask))) >> 12;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pmd_pfn(pmd_t pmd)
>{
> phys_addr_t pfn = pmd_val(pmd);
> pfn ^= protnone_mask(pfn);
> return (pfn & pmd_pfn_mask(pmd)) >> 12;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pud_pfn(pud_t pud)
>{
> phys_addr_t pfn = pud_val(pud);
> pfn ^= protnone_mask(pfn);
> return (pfn & pud_pfn_mask(pud)) >> 12;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long p4d_pfn(p4d_t p4d)
>{
> return (p4d_val(p4d) & p4d_pfn_mask(p4d)) >> 12;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pgd_pfn(pgd_t pgd)
>{
> return (pgd_val(pgd) & ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask))) >> 12;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int p4d_large(p4d_t p4d)
>{
>
> return 0;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_large(pmd_t pte)
>{
> return pmd_flags(pte) & (((pteval_t)(1)) << 7);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_trans_huge(pmd_t pmd)
>{
> return (pmd_val(pmd) & ((((pteval_t)(1)) << 7)|(((u64)(1)) << 58))) == (((pteval_t)(1)) << 7);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_trans_huge(pud_t pud)
>{
> return (pud_val(pud) & ((((pteval_t)(1)) << 7)|(((u64)(1)) << 58))) == (((pteval_t)(1)) << 7);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int has_transparent_hugepage(void)
>{
> return (__builtin_constant_p(( 0*32+ 3)) && ( (((( 0*32+ 3))>>5)==(0) && (1UL<<((( 0*32+ 3))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 0*32+ 3))>>5)==(1) && (1UL<<((( 0*32+ 3))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 0*32+ 3))>>5)==(2) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(3) && (1UL<<((( 0*32+ 3))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 0*32+ 3))>>5)==(4) && (1UL<<((( 0*32+ 3))&31) & (0) )) || (((( 0*32+ 3))>>5)==(5) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(6) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(7) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(8) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(9) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(10) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(11) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(12) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(13) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(14) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(15) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(16) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(17) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(18) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(19) && (1UL<<((( 0*32+ 3))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 0*32+ 3), (unsigned long *)((&boot_cpu_data)->x86_capability)));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_devmap(pmd_t pmd)
>{
> return !!(pmd_val(pmd) & (((u64)(1)) << 58));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_devmap(pud_t pud)
>{
> return !!(pud_val(pud) & (((u64)(1)) << 58));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_devmap(pgd_t pgd)
>{
> return 0;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_set_flags(pte_t pte, pteval_t set)
>{
> pteval_t v = native_pte_val(pte);
>
> return native_make_pte(v | set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_clear_flags(pte_t pte, pteval_t clear)
>{
> pteval_t v = native_pte_val(pte);
>
> return native_make_pte(v & ~clear);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_uffd_wp(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 10);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkuffd_wp(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 10));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_clear_uffd_wp(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 10));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkclean(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 6));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkold(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_wrprotect(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkexec(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 63));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkdirty(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkyoung(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkwrite(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkhuge(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 7));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_clrhuge(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 7));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkglobal(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 8));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_clrglobal(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 8));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkspecial(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 9));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mkdevmap(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 9)|(((u64)(1)) << 58));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_set_flags(pmd_t pmd, pmdval_t set)
>{
> pmdval_t v = native_pmd_val(pmd);
>
> return native_make_pmd(v | set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_clear_flags(pmd_t pmd, pmdval_t clear)
>{
> pmdval_t v = native_pmd_val(pmd);
>
> return native_make_pmd(v & ~clear);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_uffd_wp(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 10);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkuffd_wp(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 10));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_clear_uffd_wp(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 10));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkold(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkclean(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 6));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_wrprotect(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkdirty(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkdevmap(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((u64)(1)) << 58));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkhuge(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 7));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkyoung(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkwrite(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_set_flags(pud_t pud, pudval_t set)
>{
> pudval_t v = native_pud_val(pud);
>
> return native_make_pud(v | set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_clear_flags(pud_t pud, pudval_t clear)
>{
> pudval_t v = native_pud_val(pud);
>
> return native_make_pud(v & ~clear);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkold(pud_t pud)
>{
> return pud_clear_flags(pud, (((pteval_t)(1)) << 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkclean(pud_t pud)
>{
> return pud_clear_flags(pud, (((pteval_t)(1)) << 6));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_wrprotect(pud_t pud)
>{
> return pud_clear_flags(pud, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkdirty(pud_t pud)
>{
> return pud_set_flags(pud, (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkdevmap(pud_t pud)
>{
> return pud_set_flags(pud, (((u64)(1)) << 58));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkhuge(pud_t pud)
>{
> return pud_set_flags(pud, (((pteval_t)(1)) << 7));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkyoung(pud_t pud)
>{
> return pud_set_flags(pud, (((pteval_t)(1)) << 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mkwrite(pud_t pud)
>{
> return pud_set_flags(pud, (((pteval_t)(1)) << 1));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_soft_dirty(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 11);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_soft_dirty(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 11);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_soft_dirty(pud_t pud)
>{
> return pud_flags(pud) & (((pteval_t)(1)) << 11);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_mksoft_dirty(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mksoft_dirty(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_mksoft_dirty(pud_t pud)
>{
> return pud_set_flags(pud, (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_clear_soft_dirty(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_clear_soft_dirty(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 11));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pud_clear_soft_dirty(pud_t pud)
>{
> return pud_clear_flags(pud, (((pteval_t)(1)) << 11));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprotval_t massage_pgprot(pgprot_t pgprot)
>{
> pgprotval_t protval = ((pgprot).pgprot);
>
> if (protval & (((pteval_t)(1)) << 0))
>  protval &= __supported_pte_mask;
>
> return protval;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprotval_t check_pgprot(pgprot_t pgprot)
>{
> pgprotval_t massaged_val = massage_pgprot(pgprot);
># 572 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
> return massaged_val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pfn_pte(unsigned long page_nr, pgprot_t pgprot)
>{
> phys_addr_t pfn = (phys_addr_t)page_nr << 12;
> pfn ^= protnone_mask(((pgprot).pgprot));
> pfn &= ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask));
> return __pte(pfn | check_pgprot(pgprot));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pfn_pmd(unsigned long page_nr, pgprot_t pgprot)
>{
> phys_addr_t pfn = (phys_addr_t)page_nr << 12;
> pfn ^= protnone_mask(((pgprot).pgprot));
> pfn &= (((signed long)(~(((1UL) << 21)-1))) & physical_mask);
> return __pmd(pfn | check_pgprot(pgprot));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pfn_pud(unsigned long page_nr, pgprot_t pgprot)
>{
> phys_addr_t pfn = (phys_addr_t)page_nr << 12;
> pfn ^= protnone_mask(((pgprot).pgprot));
> pfn &= (((signed long)(~(((1UL) << 30)-1))) & physical_mask);
> return __pud(pfn | check_pgprot(pgprot));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_mkinvalid(pmd_t pmd)
>{
> return pfn_pmd(pmd_pfn(pmd),
>        ((pgprot_t) { (pmd_flags(pmd) & ~((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 8))) } ));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 flip_protnone_guard(u64 oldval, u64 val, u64 mask);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_modify(pte_t pte, pgprot_t newprot)
>{
> pteval_t val = pte_val(pte), oldval = val;
>
>
>
>
>
> val &= (((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3) | (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 5) | (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11) | (((u64)(1)) << 58) | (((pteval_t)(sme_me_mask))) | (((pteval_t)(1)) << 10));
> val |= check_pgprot(newprot) & ~(((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3) | (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 5) | (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11) | (((u64)(1)) << 58) | (((pteval_t)(sme_me_mask))) | (((pteval_t)(1)) << 10));
> val = flip_protnone_guard(oldval, val, ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)));
> return __pte(val);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_modify(pmd_t pmd, pgprot_t newprot)
>{
> pmdval_t val = pmd_val(pmd), oldval = val;
>
> val &= ((((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3) | (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 5) | (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11) | (((u64)(1)) << 58) | (((pteval_t)(sme_me_mask))) | (((pteval_t)(1)) << 10)) | (((pteval_t)(1)) << 7));
> val |= check_pgprot(newprot) & ~((((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3) | (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 5) | (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11) | (((u64)(1)) << 58) | (((pteval_t)(sme_me_mask))) | (((pteval_t)(1)) << 10)) | (((pteval_t)(1)) << 7));
> val = flip_protnone_guard(oldval, val, (((signed long)(~(((1UL) << 21)-1))) & physical_mask));
> return __pmd(val);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t pgprot_modify(pgprot_t oldprot, pgprot_t newprot)
>{
> pgprotval_t preservebits = ((oldprot).pgprot) & (((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3) | (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 5) | (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11) | (((u64)(1)) << 58) | (((pteval_t)(sme_me_mask))) | (((pteval_t)(1)) << 10));
> pgprotval_t addbits = ((newprot).pgprot) & ~(((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3) | (((pteval_t)(1)) << 9) | (((pteval_t)(1)) << 5) | (((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 11) | (((u64)(1)) << 58) | (((pteval_t)(sme_me_mask))) | (((pteval_t)(1)) << 10));
> return ((pgprot_t) { (preservebits | addbits) } );
>}
># 650 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_new_memtype_allowed(u64 paddr, unsigned long size,
>      enum page_cache_mode pcm,
>      enum page_cache_mode new_pcm)
>{
>
>
>
> if (x86_platform.is_untracked_pat_range(paddr, paddr + size))
>  return 1;
># 668 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
> if ((pcm == _PAGE_CACHE_MODE_UC_MINUS &&
>      new_pcm == _PAGE_CACHE_MODE_WB) ||
>     (pcm == _PAGE_CACHE_MODE_WC &&
>      new_pcm == _PAGE_CACHE_MODE_WB) ||
>     (pcm == _PAGE_CACHE_MODE_WT &&
>      new_pcm == _PAGE_CACHE_MODE_WB) ||
>     (pcm == _PAGE_CACHE_MODE_WT &&
>      new_pcm == _PAGE_CACHE_MODE_WC)) {
>  return 0;
> }
>
> return 1;
>}
>
>pmd_t *populate_extra_pmd(unsigned long vaddr);
>pte_t *populate_extra_pte(unsigned long vaddr);
>
>
>pgd_t __pti_set_user_pgtbl(pgd_t *pgdp, pgd_t pgd);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgd_t pti_set_user_pgtbl(pgd_t *pgdp, pgd_t pgd)
>{
> if (!( __builtin_constant_p((__builtin_constant_p(( 7*32+11)) && ( (((( 7*32+11))>>5)==(0) && (1UL<<((( 7*32+11))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 7*32+11))>>5)==(1) && (1UL<<((( 7*32+11))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 7*32+11))>>5)==(2) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(3) && (1UL<<((( 7*32+11))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 7*32+11))>>5)==(4) && (1UL<<((( 7*32+11))&31) & (0) )) || (((( 7*32+11))>>5)==(5) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(6) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(7) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(8) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(9) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(10) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(11) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(12) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(13) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(14) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(15) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(16) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(17) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(18) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(19) && (1UL<<((( 7*32+11))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 7*32+11), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p(( 7*32+11)) && ( (((( 7*32+11))>>5)==(0) && (1UL<<((( 7*32+11))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 7*32+11))>>5)==(1) && (1UL<<((( 7*32+11))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 7*32+11))>>5)==(2) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(3) && (1UL<<((( 7*32+11))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 7*32+11))>>5)==(4) && (1UL<<((( 7*32+11))&31) & (0) )) || (((( 7*32+11))>>5)==(5) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(6) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(7) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(8) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(9) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(10) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(11) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(12) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(13) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(14) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(15) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(16) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(17) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(18) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(19) && (1UL<<((( 7*32+11))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 7*32+11), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has(( 7*32+11)) ))
>  return pgd;
> return __pti_set_user_pgtbl(pgdp, pgd);
>}
># 712 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h"
># 1 "./arch/x86/include/generated/asm/kmap_size.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h" 2
># 42 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/vsyscall.h" 1
>
>
>
>
>enum vsyscall_num {
> __NR_vgettimeofday,
> __NR_vtime,
> __NR_vgetcpu,
>};
># 43 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h" 2
># 81 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h"
>enum fixed_addresses {
>
>
>
>
> VSYSCALL_PAGE = (((((((-10UL << 20) + ((1UL) << 12))-1) | ((__typeof__((-10UL << 20) + ((1UL) << 12)))((1<<21)-1)))+1) - ((1UL) << 12)) - (-10UL << 20)) >> 12,
>
>
> FIX_DBGP_BASE,
> FIX_EARLYCON_MEM_BASE,
>
> FIX_OHCI1394_BASE,
>
>
> FIX_APIC_BASE,
>
>
> FIX_IO_APIC_BASE_0,
> FIX_IO_APIC_BASE_END = FIX_IO_APIC_BASE_0 + 128 - 1,
># 109 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h"
> FIX_PARAVIRT_BOOTMAP,
>
>
>
>
> FIX_APEI_GHES_IRQ,
> FIX_APEI_GHES_NMI,
>
>
> __end_of_permanent_fixed_addresses,
># 130 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h"
> FIX_BTMAP_END =
>  (__end_of_permanent_fixed_addresses ^
>   (__end_of_permanent_fixed_addresses + (64 * 8) - 1)) &
>  -512
>  ? __end_of_permanent_fixed_addresses + (64 * 8) -
>    (__end_of_permanent_fixed_addresses & ((64 * 8) - 1))
>  : __end_of_permanent_fixed_addresses,
> FIX_BTMAP_BEGIN = FIX_BTMAP_END + (64 * 8) - 1,
>
>
>
>
> FIX_TBOOT_BASE,
>
> __end_of_fixed_addresses
>};
>
>
>extern void reserve_top_address(unsigned long reserve);
>
>
>
>
>
>
>extern int fixmaps_set;
>
>extern pte_t *pkmap_page_table;
>
>void __native_set_fixmap(enum fixed_addresses idx, pte_t pte);
>void native_set_fixmap(unsigned idx,
>         phys_addr_t phys, pgprot_t flags);
># 182 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h"
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) *early_memremap_encrypted(resource_size_t phys_addr,
>          unsigned long size);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) *early_memremap_encrypted_wp(resource_size_t phys_addr,
>      unsigned long size);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) *early_memremap_decrypted(resource_size_t phys_addr,
>          unsigned long size);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) *early_memremap_decrypted_wp(resource_size_t phys_addr,
>      unsigned long size);
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/fixmap.h" 1
># 30 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/fixmap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long fix_to_virt(const unsigned int idx)
>{
> do { extern void __compiletime_assert_171(void) __attribute__((__error__("BUILD_BUG_ON failed: " "idx >= __end_of_fixed_addresses"))); if (!(!(idx >= __end_of_fixed_addresses))) __compiletime_assert_171(); } while (0);
> return (((((((-10UL << 20) + ((1UL) << 12))-1) | ((__typeof__((-10UL << 20) + ((1UL) << 12)))((1<<21)-1)))+1) - ((1UL) << 12)) - ((idx) << 12));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long virt_to_fix(const unsigned long vaddr)
>{
> do { if (__builtin_expect(!!(vaddr >= ((((((-10UL << 20) + ((1UL) << 12))-1) | ((__typeof__((-10UL << 20) + ((1UL) << 12)))((1<<21)-1)))+1) - ((1UL) << 12)) || vaddr < (((((((-10UL << 20) + ((1UL) << 12))-1) | ((__typeof__((-10UL << 20) + ((1UL) << 12)))((1<<21)-1)))+1) - ((1UL) << 12)) - (__end_of_permanent_fixed_addresses << 12))), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/asm-generic/fixmap.h"), "i" (38), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("172" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "172" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> return ((((((((-10UL << 20) + ((1UL) << 12))-1) | ((__typeof__((-10UL << 20) + ((1UL) << 12)))((1<<21)-1)))+1) - ((1UL) << 12)) - ((vaddr)&(~(((1UL) << 12)-1)))) >> 12);
>}
># 192 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fixmap.h" 2
>
>
>
>
>void __early_set_fixmap(enum fixed_addresses idx,
>   phys_addr_t phys, pgprot_t flags);
># 18 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h" 2
>
>extern p4d_t level4_kernel_pgt[512];
>extern p4d_t level4_ident_pgt[512];
>extern pud_t level3_kernel_pgt[512];
>extern pud_t level3_ident_pgt[512];
>extern pmd_t level2_kernel_pgt[512];
>extern pmd_t level2_fixmap_pgt[512];
>extern pmd_t level2_ident_pgt[512];
>extern pte_t level1_fixmap_pgt[512 * 2];
>extern pgd_t init_top_pgt[];
>
>
>
>extern void paging_init(void);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sync_initial_page_table(void) { }
># 54 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h"
>struct mm_struct;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mm_p4d_folded(struct mm_struct *mm)
>{
> return !(__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) ));
>}
>
>void set_pte_vaddr_p4d(p4d_t *p4d_page, unsigned long vaddr, pte_t new_pte);
>void set_pte_vaddr_pud(pud_t *pud_page, unsigned long vaddr, pte_t new_pte);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_set_pte(pte_t *ptep, pte_t pte)
>{
> do { do { extern void __compiletime_assert_173(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*ptep) == sizeof(char) || sizeof(*ptep) == sizeof(short) || sizeof(*ptep) == sizeof(int) || sizeof(*ptep) == sizeof(long)) || sizeof(*ptep) == sizeof(long long))) __compiletime_assert_173(); } while (0); do { *(volatile typeof(*ptep) *)&(*ptep) = (pte); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_pte_clear(struct mm_struct *mm, unsigned long addr,
>        pte_t *ptep)
>{
> native_set_pte(ptep, native_make_pte(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_set_pte_atomic(pte_t *ptep, pte_t pte)
>{
> native_set_pte(ptep, pte);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_set_pmd(pmd_t *pmdp, pmd_t pmd)
>{
> do { do { extern void __compiletime_assert_174(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pmdp) == sizeof(char) || sizeof(*pmdp) == sizeof(short) || sizeof(*pmdp) == sizeof(int) || sizeof(*pmdp) == sizeof(long)) || sizeof(*pmdp) == sizeof(long long))) __compiletime_assert_174(); } while (0); do { *(volatile typeof(*pmdp) *)&(*pmdp) = (pmd); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_pmd_clear(pmd_t *pmd)
>{
> native_set_pmd(pmd, native_make_pmd(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t native_ptep_get_and_clear(pte_t *xp)
>{
>
> return native_make_pte(({ typeof(&xp->pte) __ai_ptr = (&xp->pte); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__ (*((__ai_ptr))) __ret = ((0)); switch (sizeof(*((__ai_ptr)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; }); }));
>
>
>
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t native_pmdp_get_and_clear(pmd_t *xp)
>{
>
> return native_make_pmd(({ typeof(&xp->pmd) __ai_ptr = (&xp->pmd); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__ (*((__ai_ptr))) __ret = ((0)); switch (sizeof(*((__ai_ptr)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; }); }));
>
>
>
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_set_pud(pud_t *pudp, pud_t pud)
>{
> do { do { extern void __compiletime_assert_175(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pudp) == sizeof(char) || sizeof(*pudp) == sizeof(short) || sizeof(*pudp) == sizeof(int) || sizeof(*pudp) == sizeof(long)) || sizeof(*pudp) == sizeof(long long))) __compiletime_assert_175(); } while (0); do { *(volatile typeof(*pudp) *)&(*pudp) = (pud); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_pud_clear(pud_t *pud)
>{
> native_set_pud(pud, native_make_pud(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t native_pudp_get_and_clear(pud_t *xp)
>{
>
> return native_make_pud(({ typeof(&xp->pud) __ai_ptr = (&xp->pud); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__ (*((__ai_ptr))) __ret = ((0)); switch (sizeof(*((__ai_ptr)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; }); }));
># 140 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h"
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_set_p4d(p4d_t *p4dp, p4d_t p4d)
>{
> pgd_t pgd;
>
> if ((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )) || !1) {
>  do { do { extern void __compiletime_assert_176(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*p4dp) == sizeof(char) || sizeof(*p4dp) == sizeof(short) || sizeof(*p4dp) == sizeof(int) || sizeof(*p4dp) == sizeof(long)) || sizeof(*p4dp) == sizeof(long long))) __compiletime_assert_176(); } while (0); do { *(volatile typeof(*p4dp) *)&(*p4dp) = (p4d); } while (0); } while (0);
>  return;
> }
>
> pgd = native_make_pgd(native_p4d_val(p4d));
> pgd = pti_set_user_pgtbl((pgd_t *)p4dp, pgd);
> do { do { extern void __compiletime_assert_177(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*p4dp) == sizeof(char) || sizeof(*p4dp) == sizeof(short) || sizeof(*p4dp) == sizeof(int) || sizeof(*p4dp) == sizeof(long)) || sizeof(*p4dp) == sizeof(long long))) __compiletime_assert_177(); } while (0); do { *(volatile typeof(*p4dp) *)&(*p4dp) = (native_make_p4d(native_pgd_val(pgd))); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_p4d_clear(p4d_t *p4d)
>{
> native_set_p4d(p4d, native_make_p4d(0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_set_pgd(pgd_t *pgdp, pgd_t pgd)
>{
> do { do { extern void __compiletime_assert_178(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pgdp) == sizeof(char) || sizeof(*pgdp) == sizeof(short) || sizeof(*pgdp) == sizeof(int) || sizeof(*pgdp) == sizeof(long)) || sizeof(*pgdp) == sizeof(long long))) __compiletime_assert_178(); } while (0); do { *(volatile typeof(*pgdp) *)&(*pgdp) = (pti_set_user_pgtbl(pgdp, pgd)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void native_pgd_clear(pgd_t *pgd)
>{
> native_set_pgd(pgd, native_make_pgd(0));
>}
># 241 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h"
>extern int kern_addr_valid(unsigned long addr);
>extern void cleanup_highmap(void);
># 258 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h"
>extern void init_extra_mapping_uc(unsigned long phys, unsigned long size);
>extern void init_extra_mapping_wb(unsigned long phys, unsigned long size);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool gup_fast_permitted(unsigned long start, unsigned long end)
>{
> if (end >> ((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )) ? 56 : 47))
>  return false;
> return true;
>}
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable-invert.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable-invert.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __pte_needs_invert(u64 val)
>{
> return val && !(val & (((pteval_t)(1)) << 0));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 protnone_mask(u64 val)
>{
> return __pte_needs_invert(val) ? ~0ull : 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 flip_protnone_guard(u64 oldval, u64 val, u64 mask)
>{
>
>
>
>
>
> if (__pte_needs_invert(oldval) != __pte_needs_invert(val))
>  val = (val & ~mask) | (~val & mask);
> return val;
>}
># 270 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_64.h" 2
># 713 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h" 2
># 721 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_none(pte_t pte)
>{
> return !(pte.pte & ~(((((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 5))));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_same(pte_t a, pte_t b)
>{
> return a.pte == b.pte;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_present(pte_t a)
>{
> return pte_flags(a) & ((((pteval_t)(1)) << 0) | (((pteval_t)(1)) << 8));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_devmap(pte_t a)
>{
> return (pte_flags(a) & (((u64)(1)) << 58)) == (((u64)(1)) << 58);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pte_accessible(struct mm_struct *mm, pte_t a)
>{
> if (pte_flags(a) & (((pteval_t)(1)) << 0))
>  return true;
>
> if ((pte_flags(a) & (((pteval_t)(1)) << 8)) &&
>   mm_tlb_flush_pending(mm))
>  return true;
>
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_present(pmd_t pmd)
>{
>
>
>
>
>
>
> return pmd_flags(pmd) & ((((pteval_t)(1)) << 0) | (((pteval_t)(1)) << 8) | (((pteval_t)(1)) << 7));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_protnone(pte_t pte)
>{
> return (pte_flags(pte) & ((((pteval_t)(1)) << 8) | (((pteval_t)(1)) << 0)))
>  == (((pteval_t)(1)) << 8);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_protnone(pmd_t pmd)
>{
> return (pmd_flags(pmd) & ((((pteval_t)(1)) << 8) | (((pteval_t)(1)) << 0)))
>  == (((pteval_t)(1)) << 8);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_none(pmd_t pmd)
>{
>
>
> unsigned long val = native_pmd_val(pmd);
> return (val & ~((((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 5))) == 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pmd_page_vaddr(pmd_t pmd)
>{
> return (unsigned long)((void *)((unsigned long)(pmd_val(pmd) & pmd_pfn_mask(pmd))+((unsigned long)page_offset_base)));
>}
># 814 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_bad(pmd_t pmd)
>{
> return (pmd_flags(pmd) & ~(((pteval_t)(1)) << 2)) != ((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)| 0|(((pteval_t)(1)) << 6)| 0| 0| (((pteval_t)(sme_me_mask))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pages_to_mb(unsigned long npg)
>{
> return npg >> (20 - 12);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_none(pud_t pud)
>{
> return (native_pud_val(pud) & ~(((((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 5)))) == 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_present(pud_t pud)
>{
> return pud_flags(pud) & (((pteval_t)(1)) << 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t *pud_pgtable(pud_t pud)
>{
> return (pmd_t *)((void *)((unsigned long)(pud_val(pud) & pud_pfn_mask(pud))+((unsigned long)page_offset_base)));
>}
># 847 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_large(pud_t pud)
>{
> return (pud_val(pud) & ((((pteval_t)(1)) << 7) | (((pteval_t)(1)) << 0))) ==
>  ((((pteval_t)(1)) << 7) | (((pteval_t)(1)) << 0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_bad(pud_t pud)
>{
> return (pud_flags(pud) & ~(((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)| 0|(((pteval_t)(1)) << 6)| 0| 0| (((pteval_t)(sme_me_mask)))) | (((pteval_t)(1)) << 2))) != 0;
>}
># 866 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int p4d_none(p4d_t p4d)
>{
> return (native_p4d_val(p4d) & ~(((((pteval_t)(1)) << 6) | (((pteval_t)(1)) << 5)))) == 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int p4d_present(p4d_t p4d)
>{
> return p4d_flags(p4d) & (((pteval_t)(1)) << 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t *p4d_pgtable(p4d_t p4d)
>{
> return (pud_t *)((void *)((unsigned long)(p4d_val(p4d) & p4d_pfn_mask(p4d))+((unsigned long)page_offset_base)));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int p4d_bad(p4d_t p4d)
>{
> unsigned long ignore_flags = ((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)| 0|(((pteval_t)(1)) << 6)| 0| 0| (((pteval_t)(sme_me_mask)))) | (((pteval_t)(1)) << 2);
>
> if (1)
>  ignore_flags |= (((pteval_t)(1)) << 63);
>
> return (p4d_flags(p4d) & ~ignore_flags) != 0;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long p4d_index(unsigned long address)
>{
> return (address >> 39) & (ptrs_per_p4d - 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_present(pgd_t pgd)
>{
> if (!(__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )))
>  return 1;
> return pgd_flags(pgd) & (((pteval_t)(1)) << 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pgd_page_vaddr(pgd_t pgd)
>{
> return (unsigned long)((void *)((unsigned long)((unsigned long)pgd_val(pgd) & ((pteval_t)(((signed long)(~(((1UL) << 12)-1))) & physical_mask)))+((unsigned long)page_offset_base)));
>}
># 923 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4d_t *p4d_offset(pgd_t *pgd, unsigned long address)
>{
> if (!(__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )))
>  return (p4d_t *)pgd;
> return (p4d_t *)pgd_page_vaddr(*pgd) + p4d_index(address);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_bad(pgd_t pgd)
>{
> unsigned long ignore_flags = (((pteval_t)(1)) << 2);
>
> if (!(__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )))
>  return 0;
>
> if (1)
>  ignore_flags |= (((pteval_t)(1)) << 63);
>
> return (pgd_flags(pgd) & ~ignore_flags) != ((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)| 0|(((pteval_t)(1)) << 6)| 0| 0| (((pteval_t)(sme_me_mask))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_none(pgd_t pgd)
>{
> if (!(__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+ 2) & 31))|(1<<(( 3*32+ 3) & 31))|(1<<(( 3*32+ 1) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & (0|0) )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & (0|0|0|0| 0) )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 0 : ( __builtin_constant_p((__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p((16*32+16)) && ( ((((16*32+16))>>5)==(0) && (1UL<<(((16*32+16))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((16*32+16))>>5)==(1) && (1UL<<(((16*32+16))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((16*32+16))>>5)==(2) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(3) && (1UL<<(((16*32+16))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((16*32+16))>>5)==(4) && (1UL<<(((16*32+16))&31) & (0) )) || ((((16*32+16))>>5)==(5) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(6) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(7) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(8) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(9) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(10) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(11) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(12) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(13) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(14) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(15) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(16) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(17) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(18) && (1UL<<(((16*32+16))&31) & 0 )) || ((((16*32+16))>>5)==(19) && (1UL<<(((16*32+16))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((16*32+16), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has((16*32+16)) )))
>  return 0;
>
>
>
>
>
>
> return !native_pgd_val(pgd);
>}
># 964 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>extern int direct_gbpages;
>void init_mem_mapping(void);
>void early_alloc_pgt_buf(void);
>extern void memblock_find_dma_reserve(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) poking_init(void);
>unsigned long init_memory_mapping(unsigned long start,
>      unsigned long end, pgprot_t prot);
>
>
>extern pgd_t trampoline_pgd_entry;
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t native_local_ptep_get_and_clear(pte_t *ptep)
>{
> pte_t res = *ptep;
>
>
> native_pte_clear(((void *)0), 0, ptep);
> return res;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t native_local_pmdp_get_and_clear(pmd_t *pmdp)
>{
> pmd_t res = *pmdp;
>
> native_pmd_clear(pmdp);
> return res;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t native_local_pudp_get_and_clear(pud_t *pudp)
>{
> pud_t res = *pudp;
>
> native_pud_clear(pudp);
> return res;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pte_at(struct mm_struct *mm, unsigned long addr,
>         pte_t *ptep, pte_t pte)
>{
> set_pte(ptep, pte);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pmd_at(struct mm_struct *mm, unsigned long addr,
>         pmd_t *pmdp, pmd_t pmd)
>{
> set_pmd(pmdp, pmd);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_pud_at(struct mm_struct *mm, unsigned long addr,
>         pud_t *pudp, pud_t pud)
>{
> native_set_pud(pudp, pud);
>}
># 1027 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>struct vm_area_struct;
>
>
>extern int ptep_set_access_flags(struct vm_area_struct *vma,
>     unsigned long address, pte_t *ptep,
>     pte_t entry, int dirty);
>
>
>extern int ptep_test_and_clear_young(struct vm_area_struct *vma,
>         unsigned long addr, pte_t *ptep);
>
>
>extern int ptep_clear_flush_young(struct vm_area_struct *vma,
>      unsigned long address, pte_t *ptep);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t ptep_get_and_clear(struct mm_struct *mm, unsigned long addr,
>           pte_t *ptep)
>{
> pte_t pte = native_ptep_get_and_clear(ptep);
> return pte;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t ptep_get_and_clear_full(struct mm_struct *mm,
>         unsigned long addr, pte_t *ptep,
>         int full)
>{
> pte_t pte;
> if (full) {
>
>
>
>
>  pte = native_local_ptep_get_and_clear(ptep);
> } else {
>  pte = ptep_get_and_clear(mm, addr, ptep);
> }
> return pte;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptep_set_wrprotect(struct mm_struct *mm,
>          unsigned long addr, pte_t *ptep)
>{
> clear_bit(1, (unsigned long *)&ptep->pte);
>}
>
>
>
>
>
>
>extern int pmdp_set_access_flags(struct vm_area_struct *vma,
>     unsigned long address, pmd_t *pmdp,
>     pmd_t entry, int dirty);
>extern int pudp_set_access_flags(struct vm_area_struct *vma,
>     unsigned long address, pud_t *pudp,
>     pud_t entry, int dirty);
>
>
>extern int pmdp_test_and_clear_young(struct vm_area_struct *vma,
>         unsigned long addr, pmd_t *pmdp);
>extern int pudp_test_and_clear_young(struct vm_area_struct *vma,
>         unsigned long addr, pud_t *pudp);
>
>
>extern int pmdp_clear_flush_young(struct vm_area_struct *vma,
>      unsigned long address, pmd_t *pmdp);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_write(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmdp_huge_get_and_clear(struct mm_struct *mm, unsigned long addr,
>           pmd_t *pmdp)
>{
> return native_pmdp_get_and_clear(pmdp);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pudp_huge_get_and_clear(struct mm_struct *mm,
>     unsigned long addr, pud_t *pudp)
>{
> return native_pudp_get_and_clear(pudp);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pmdp_set_wrprotect(struct mm_struct *mm,
>          unsigned long addr, pmd_t *pmdp)
>{
> clear_bit(1, (unsigned long *)pmdp);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_write(pud_t pud)
>{
> return pud_flags(pud) & (((pteval_t)(1)) << 1);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmdp_establish(struct vm_area_struct *vma,
>  unsigned long address, pmd_t *pmdp, pmd_t pmd)
>{
> if (1) {
>  return ({ typeof(pmdp) __ai_ptr = (pmdp); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); ({ __typeof__ (*((__ai_ptr))) __ret = ((pmd)); switch (sizeof(*((__ai_ptr)))) { case 1: asm volatile ("" "xchg" "b %b0, %1\n" : "+q" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 2: asm volatile ("" "xchg" "w %w0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 4: asm volatile ("" "xchg" "l %0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; case 8: asm volatile ("" "xchg" "q %q0, %1\n" : "+r" (__ret), "+m" (*((__ai_ptr))) : : "memory", "cc"); break; default: __xchg_wrong_size(); } __ret; }); });
> } else {
>  pmd_t old = *pmdp;
>  do { do { extern void __compiletime_assert_179(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pmdp) == sizeof(char) || sizeof(*pmdp) == sizeof(short) || sizeof(*pmdp) == sizeof(int) || sizeof(*pmdp) == sizeof(long)) || sizeof(*pmdp) == sizeof(long long))) __compiletime_assert_179(); } while (0); do { *(volatile typeof(*pmdp) *)&(*pmdp) = (pmd); } while (0); } while (0);
>  return old;
> }
>}
># 1152 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pgdp_maps_userspace(void *__ptr)
>{
> unsigned long ptr = (unsigned long)__ptr;
>
> return (((ptr & ~(~(((1UL) << 12)-1))) / sizeof(pgd_t)) < ((((1UL) << 12) / 2) / sizeof(pgd_t)));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_large(pgd_t pgd) { return 0; }
># 1175 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *ptr_set_bit(void *ptr, int bit)
>{
> unsigned long __ptr = (unsigned long)ptr;
>
> __ptr |= ((((1UL))) << (bit));
> return (void *)__ptr;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *ptr_clear_bit(void *ptr, int bit)
>{
> unsigned long __ptr = (unsigned long)ptr;
>
> __ptr &= ~((((1UL))) << (bit));
> return (void *)__ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgd_t *kernel_to_user_pgdp(pgd_t *pgdp)
>{
> return ptr_set_bit(pgdp, 12);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgd_t *user_to_kernel_pgdp(pgd_t *pgdp)
>{
> return ptr_clear_bit(pgdp, 12);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4d_t *kernel_to_user_p4dp(p4d_t *p4dp)
>{
> return ptr_set_bit(p4dp, 12);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4d_t *user_to_kernel_p4dp(p4d_t *p4dp)
>{
> return ptr_clear_bit(p4dp, 12);
>}
># 1221 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clone_pgd_range(pgd_t *dst, pgd_t *src, int count)
>{
> memcpy(dst, src, count * sizeof(pgd_t));
>
> if (!( __builtin_constant_p((__builtin_constant_p(( 7*32+11)) && ( (((( 7*32+11))>>5)==(0) && (1UL<<((( 7*32+11))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 7*32+11))>>5)==(1) && (1UL<<((( 7*32+11))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 7*32+11))>>5)==(2) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(3) && (1UL<<((( 7*32+11))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 7*32+11))>>5)==(4) && (1UL<<((( 7*32+11))&31) & (0) )) || (((( 7*32+11))>>5)==(5) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(6) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(7) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(8) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(9) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(10) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(11) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(12) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(13) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(14) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(15) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(16) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(17) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(18) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(19) && (1UL<<((( 7*32+11))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 7*32+11), (unsigned long *)((&boot_cpu_data)->x86_capability)))) ? (__builtin_constant_p(( 7*32+11)) && ( (((( 7*32+11))>>5)==(0) && (1UL<<((( 7*32+11))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 7*32+11))>>5)==(1) && (1UL<<((( 7*32+11))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 7*32+11))>>5)==(2) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(3) && (1UL<<((( 7*32+11))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 7*32+11))>>5)==(4) && (1UL<<((( 7*32+11))&31) & (0) )) || (((( 7*32+11))>>5)==(5) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(6) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(7) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(8) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(9) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(10) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(11) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(12) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(13) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(14) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(15) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(16) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(17) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(18) && (1UL<<((( 7*32+11))&31) & 0 )) || (((( 7*32+11))>>5)==(19) && (1UL<<((( 7*32+11))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 7*32+11), (unsigned long *)((&boot_cpu_data)->x86_capability))) : _static_cpu_has(( 7*32+11)) ))
>  return;
>
> memcpy(kernel_to_user_pgdp(dst), kernel_to_user_pgdp(src),
>        count * sizeof(pgd_t));
>
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_level_shift(enum pg_level level)
>{
> return (12 - ( __builtin_constant_p(512) ? ((512) < 2 ? 0 : 63 - __builtin_clzll(512)) : (sizeof(512) <= 4) ? __ilog2_u32(512) : __ilog2_u64(512) )) + level * ( __builtin_constant_p(512) ? ((512) < 2 ? 0 : 63 - __builtin_clzll(512)) : (sizeof(512) <= 4) ? __ilog2_u32(512) : __ilog2_u64(512) );
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_level_size(enum pg_level level)
>{
> return 1UL << page_level_shift(level);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_level_mask(enum pg_level level)
>{
> return ~(page_level_size(level) - 1);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_mmu_cache(struct vm_area_struct *vma,
>  unsigned long addr, pte_t *ptep)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_mmu_cache_pmd(struct vm_area_struct *vma,
>  unsigned long addr, pmd_t *pmd)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_mmu_cache_pud(struct vm_area_struct *vma,
>  unsigned long addr, pud_t *pud)
>{
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_swp_mksoft_dirty(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_swp_soft_dirty(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_swp_clear_soft_dirty(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 1));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_swp_mksoft_dirty(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_swp_soft_dirty(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_swp_clear_soft_dirty(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 1));
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_swp_mkuffd_wp(pte_t pte)
>{
> return pte_set_flags(pte, (((pteval_t)(1)) << 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_swp_uffd_wp(pte_t pte)
>{
> return pte_flags(pte) & (((pteval_t)(1)) << 2);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_swp_clear_uffd_wp(pte_t pte)
>{
> return pte_clear_flags(pte, (((pteval_t)(1)) << 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_swp_mkuffd_wp(pmd_t pmd)
>{
> return pmd_set_flags(pmd, (((pteval_t)(1)) << 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_swp_uffd_wp(pmd_t pmd)
>{
> return pmd_flags(pmd) & (((pteval_t)(1)) << 2);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_swp_clear_uffd_wp(pmd_t pmd)
>{
> return pmd_clear_flags(pmd, (((pteval_t)(1)) << 2));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 pte_flags_pkey(unsigned long pte_flags)
>{
>
>
> return (pte_flags & ((((pteval_t)(1)) << 59) | (((pteval_t)(1)) << 60) | (((pteval_t)(1)) << 61) | (((pteval_t)(1)) << 62))) >> 59;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __pkru_allows_pkey(u16 pkey, bool write)
>{
> u32 pkru = read_pkru();
>
> if (!__pkru_allows_read(pkru, pkey))
>  return false;
> if (write && !__pkru_allows_write(pkru, pkey))
>  return false;
>
> return true;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __pte_access_permitted(unsigned long pteval, bool write)
>{
> unsigned long need_pte_bits = (((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 2);
>
> if (write)
>  need_pte_bits |= (((pteval_t)(1)) << 1);
>
> if ((pteval & need_pte_bits) != need_pte_bits)
>  return 0;
>
> return __pkru_allows_pkey(pte_flags_pkey(pteval), write);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pte_access_permitted(pte_t pte, bool write)
>{
> return __pte_access_permitted(pte_val(pte), write);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pmd_access_permitted(pmd_t pmd, bool write)
>{
> return __pte_access_permitted(pmd_val(pmd), write);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pud_access_permitted(pud_t pud, bool write)
>{
> return __pte_access_permitted(pud_val(pud), write);
>}
>
>
>extern bool pfn_modify_allowed(unsigned long pfn, pgprot_t prot);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_has_pfn_modify_check(void)
>{
> return (__builtin_constant_p((((22*32 + (18))))) && ( ((((((22*32 + (18)))))>>5)==(0) && (1UL<<(((((22*32 + (18)))))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((((22*32 + (18)))))>>5)==(1) && (1UL<<(((((22*32 + (18)))))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((((22*32 + (18)))))>>5)==(2) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(3) && (1UL<<(((((22*32 + (18)))))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((((22*32 + (18)))))>>5)==(4) && (1UL<<(((((22*32 + (18)))))&31) & (0) )) || ((((((22*32 + (18)))))>>5)==(5) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(6) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(7) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(8) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(9) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(10) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(11) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(12) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(13) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(14) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(15) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(16) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(17) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(18) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((((((22*32 + (18)))))>>5)==(19) && (1UL<<(((((22*32 + (18)))))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((((22*32 + (18)))), (unsigned long *)((&boot_cpu_data)->x86_capability)));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_faults_on_old_pte(void)
>{
> return false;
>}
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h" 2
># 61 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pte_index(unsigned long address)
>{
> return (address >> 12) & (512 - 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pmd_index(unsigned long address)
>{
> return (address >> 21) & (512 - 1);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pud_index(unsigned long address)
>{
> return (address >> 30) & (512 - 1);
>}
># 88 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t *pte_offset_kernel(pmd_t *pmd, unsigned long address)
>{
> return (pte_t *)pmd_page_vaddr(*pmd) + pte_index(address);
>}
># 107 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t *pmd_offset(pud_t *pud, unsigned long address)
>{
> return pud_pgtable(*pud) + pmd_index(address);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t *pud_offset(p4d_t *p4d, unsigned long address)
>{
> return p4d_pgtable(*p4d) + pud_index(address);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgd_t *pgd_offset_pgd(pgd_t *pgd, unsigned long address)
>{
> return (pgd + (((address) >> pgdir_shift) & (512 - 1)));
>};
># 149 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t *pmd_off(struct mm_struct *mm, unsigned long va)
>{
> return pmd_offset(pud_offset(p4d_offset(pgd_offset_pgd((mm)->pgd, (va)), va), va), va);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t *pmd_off_k(unsigned long va)
>{
> return pmd_offset(pud_offset(p4d_offset(pgd_offset_pgd((&init_mm)->pgd, ((va))), va), va), va);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t *virt_to_kpte(unsigned long vaddr)
>{
> pmd_t *pmd = pmd_off_k(vaddr);
>
> return pmd_none(*pmd) ? ((void *)0) : pte_offset_kernel(pmd, vaddr);
>}
># 273 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t ptep_get(pte_t *ptep)
>{
> return ({ do { extern void __compiletime_assert_180(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*ptep) == sizeof(char) || sizeof(*ptep) == sizeof(short) || sizeof(*ptep) == sizeof(int) || sizeof(*ptep) == sizeof(long)) || sizeof(*ptep) == sizeof(long long))) __compiletime_assert_180(); } while (0); (*(const volatile typeof( _Generic((*ptep), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*ptep))) *)&(*ptep)); });
>}
># 328 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t ptep_get_lockless(pte_t *ptep)
>{
> return ptep_get(ptep);
>}
># 360 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmdp_huge_get_and_clear_full(struct vm_area_struct *vma,
>         unsigned long address, pmd_t *pmdp,
>         int full)
>{
> return pmdp_huge_get_and_clear(vma->vm_mm, address, pmdp);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t pudp_huge_get_and_clear_full(struct mm_struct *mm,
>         unsigned long address, pud_t *pudp,
>         int full)
>{
> return pudp_huge_get_and_clear(mm, address, pudp);
>}
># 399 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_mmu_tlb(struct vm_area_struct *vma,
>    unsigned long address, pte_t *ptep)
>{
>}
># 412 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pte_clear_not_present_full(struct mm_struct *mm,
>           unsigned long address,
>           pte_t *ptep,
>           int full)
>{
> pte_clear(mm, address, ptep);
>}
>
>
>
>extern pte_t ptep_clear_flush(struct vm_area_struct *vma,
>         unsigned long address,
>         pte_t *ptep);
>
>
>
>extern pmd_t pmdp_huge_clear_flush(struct vm_area_struct *vma,
>         unsigned long address,
>         pmd_t *pmdp);
>extern pud_t pudp_huge_clear_flush(struct vm_area_struct *vma,
>         unsigned long address,
>         pud_t *pudp);
># 454 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t pte_sw_mkyoung(pte_t pte)
>{
> return pte;
>}
># 503 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pudp_set_wrprotect(struct mm_struct *mm,
>          unsigned long address, pud_t *pudp)
>{
> pud_t old_pud = *pudp;
>
> set_pud_at(mm, address, pudp, pud_wrprotect(old_pud));
>}
># 521 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>extern pmd_t pmdp_collapse_flush(struct vm_area_struct *vma,
>     unsigned long address, pmd_t *pmdp);
># 536 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>extern void pgtable_trans_huge_deposit(struct mm_struct *mm, pmd_t *pmdp,
>           pgtable_t pgtable);
>
>
>
>extern pgtable_t pgtable_trans_huge_withdraw(struct mm_struct *mm, pmd_t *pmdp);
># 550 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t generic_pmdp_establish(struct vm_area_struct *vma,
>  unsigned long address, pmd_t *pmdp, pmd_t pmd)
>{
> pmd_t old_pmd = *pmdp;
> set_pmd_at(vma->vm_mm, address, pmdp, pmd);
> return old_pmd;
>}
>
>
>
>extern pmd_t pmdp_invalidate(struct vm_area_struct *vma, unsigned long address,
>       pmd_t *pmdp);
># 578 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pte_unused(pte_t pte)
>{
> return 0;
>}
># 610 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_same(pmd_t pmd_a, pmd_t pmd_b)
>{
> return pmd_val(pmd_a) == pmd_val(pmd_b);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_same(pud_t pud_a, pud_t pud_b)
>{
> return pud_val(pud_a) == pud_val(pud_b);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int p4d_same(p4d_t p4d_a, p4d_t p4d_b)
>{
> return p4d_val(p4d_a) == p4d_val(p4d_b);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_same(pgd_t pgd_a, pgd_t pgd_b)
>{
> return pgd_val(pgd_a) == pgd_val(pgd_b);
>}
># 682 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_do_swap_page(struct mm_struct *mm,
>         struct vm_area_struct *vma,
>         unsigned long addr,
>         pte_t pte, pte_t oldpte)
>{
>
>}
># 700 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_unmap_one(struct mm_struct *mm,
>      struct vm_area_struct *vma,
>      unsigned long addr,
>      pte_t orig_pte)
>{
> return 0;
>}
># 715 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_prepare_to_swap(struct page *page)
>{
> return 0;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_swap_invalidate_page(int type, unsigned long offset)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_swap_invalidate_area(int type)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_swap_restore(swp_entry_t entry, struct page *page)
>{
>}
># 790 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>void pgd_clear_bad(pgd_t *);
>
>
>void p4d_clear_bad(p4d_t *);
>
>
>
>
>
>void pud_clear_bad(pud_t *);
>
>
>
>
>void pmd_clear_bad(pmd_t *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pgd_none_or_clear_bad(pgd_t *pgd)
>{
> if (pgd_none(*pgd))
>  return 1;
> if (__builtin_expect(!!(pgd_bad(*pgd)), 0)) {
>  pgd_clear_bad(pgd);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int p4d_none_or_clear_bad(p4d_t *p4d)
>{
> if (p4d_none(*p4d))
>  return 1;
> if (__builtin_expect(!!(p4d_bad(*p4d)), 0)) {
>  p4d_clear_bad(p4d);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_none_or_clear_bad(pud_t *pud)
>{
> if (pud_none(*pud))
>  return 1;
> if (__builtin_expect(!!(pud_bad(*pud)), 0)) {
>  pud_clear_bad(pud);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_none_or_clear_bad(pmd_t *pmd)
>{
> if (pmd_none(*pmd))
>  return 1;
> if (__builtin_expect(!!(pmd_bad(*pmd)), 0)) {
>  pmd_clear_bad(pmd);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t __ptep_modify_prot_start(struct vm_area_struct *vma,
>          unsigned long addr,
>          pte_t *ptep)
>{
>
>
>
>
>
> return ptep_get_and_clear(vma->vm_mm, addr, ptep);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __ptep_modify_prot_commit(struct vm_area_struct *vma,
>          unsigned long addr,
>          pte_t *ptep, pte_t pte)
>{
>
>
>
>
> set_pte_at(vma->vm_mm, addr, ptep, pte);
>}
># 1129 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>extern int track_pfn_remap(struct vm_area_struct *vma, pgprot_t *prot,
>      unsigned long pfn, unsigned long addr,
>      unsigned long size);
>extern void track_pfn_insert(struct vm_area_struct *vma, pgprot_t *prot,
>        pfn_t pfn);
>extern int track_pfn_copy(struct vm_area_struct *vma);
>extern void untrack_pfn(struct vm_area_struct *vma, unsigned long pfn,
>   unsigned long size);
>extern void untrack_pfn_moved(struct vm_area_struct *vma);
># 1152 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_zero_pfn(unsigned long pfn)
>{
> extern unsigned long zero_pfn;
> return pfn == zero_pfn;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long my_zero_pfn(unsigned long addr)
>{
> extern unsigned long zero_pfn;
> return zero_pfn;
>}
># 1225 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_none_or_trans_huge_or_dev_or_clear_bad(pud_t *pud)
>{
> pud_t pudval = ({ do { extern void __compiletime_assert_181(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pud) == sizeof(char) || sizeof(*pud) == sizeof(short) || sizeof(*pud) == sizeof(int) || sizeof(*pud) == sizeof(long)) || sizeof(*pud) == sizeof(long long))) __compiletime_assert_181(); } while (0); (*(const volatile typeof( _Generic((*pud), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*pud))) *)&(*pud)); });
>
> if (pud_none(pudval) || pud_trans_huge(pudval) || pud_devmap(pudval))
>  return 1;
> if (__builtin_expect(!!(pud_bad(pudval)), 0)) {
>  pud_clear_bad(pud);
>  return 1;
> }
> return 0;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pud_trans_unstable(pud_t *pud)
>{
>
>
> return pud_none_or_trans_huge_or_dev_or_clear_bad(pud);
>
>
>
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t pmd_read_atomic(pmd_t *pmdp)
>{
>
>
>
>
>
> return *pmdp;
>}
># 1285 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_none_or_trans_huge_or_clear_bad(pmd_t *pmd)
>{
> pmd_t pmdval = pmd_read_atomic(pmd);
># 1303 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
> __asm__ __volatile__("": : :"memory");
># 1320 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
> if (pmd_none(pmdval) || pmd_trans_huge(pmdval) ||
>  (1 && !pmd_present(pmdval)))
>  return 1;
> if (__builtin_expect(!!(pmd_bad(pmdval)), 0)) {
>  pmd_clear_bad(pmd);
>  return 1;
> }
> return 0;
>}
># 1342 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_trans_unstable(pmd_t *pmd)
>{
>
> return pmd_none_or_trans_huge_or_clear_bad(pmd);
>
>
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pmd_devmap_trans_unstable(pmd_t *pmd)
>{
> return pmd_devmap(*pmd) || pmd_trans_unstable(pmd);
>}
># 1387 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>int p4d_set_huge(p4d_t *p4d, phys_addr_t addr, pgprot_t prot);
>int p4d_clear_huge(p4d_t *p4d);
># 1400 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>int pud_set_huge(pud_t *pud, phys_addr_t addr, pgprot_t prot);
>int pmd_set_huge(pmd_t *pmd, phys_addr_t addr, pgprot_t prot);
>int pud_clear_huge(pud_t *pud);
>int pmd_clear_huge(pmd_t *pmd);
>int p4d_free_pud_page(p4d_t *p4d, unsigned long addr);
>int pud_free_pmd_page(pud_t *pud, unsigned long addr);
>int pmd_free_pte_page(pmd_t *pmd, unsigned long addr);
># 1465 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>struct file;
>int phys_mem_access_prot_allowed(struct file *file, unsigned long pfn,
>   unsigned long size, pgprot_t *vma_prot);
>
>
>
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pgtable_cache_init(void);
># 1526 "/usr/src/linux-5.14.21-150500.53/include/linux/pgtable.h"
>typedef unsigned int pgtbl_mod_mask;
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/static_key.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h" 2
>
>
>struct kmem_cache;
>struct page;
>struct vm_struct;
>struct task_struct;
># 70 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kasan_add_zero_shadow(void *start, unsigned long size)
>{
> return 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_remove_zero_shadow(void *start,
>     unsigned long size)
>{}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_enable_current(void) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_disable_current(void) {}
># 102 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kasan_enabled(void)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kasan_has_integrated_init(void)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void kasan_alloc_pages(struct page *page,
>           unsigned int order, gfp_t flags)
>{
>
> do { extern void __compiletime_assert_182(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_182(); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void kasan_free_pages(struct page *page,
>          unsigned int order)
>{
>
> do { extern void __compiletime_assert_183(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_183(); } while (0);
>}
># 306 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) slab_flags_t kasan_never_merge(void)
>{
> return 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_unpoison_range(const void *address, size_t size) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_poison_pages(struct page *page, unsigned int order,
>          bool init) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_unpoison_pages(struct page *page, unsigned int order,
>     bool init) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_cache_create(struct kmem_cache *cache,
>          unsigned int *size,
>          slab_flags_t *flags) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_cache_create_kmalloc(struct kmem_cache *cache) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t kasan_metadata_size(struct kmem_cache *cache) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_poison_slab(struct page *page) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_unpoison_object_data(struct kmem_cache *cache,
>     void *object) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_poison_object_data(struct kmem_cache *cache,
>     void *object) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kasan_init_slab_obj(struct kmem_cache *cache,
>    const void *object)
>{
> return (void *)object;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kasan_slab_free(struct kmem_cache *s, void *object, bool init)
>{
> return false;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_kfree_large(void *ptr) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_slab_free_mempool(void *ptr) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kasan_slab_alloc(struct kmem_cache *s, void *object,
>       gfp_t flags, bool init)
>{
> return object;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kasan_kmalloc(struct kmem_cache *s, const void *object,
>    size_t size, gfp_t flags)
>{
> return (void *)object;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kasan_kmalloc_large(const void *ptr, size_t size, gfp_t flags)
>{
> return (void *)ptr;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kasan_krealloc(const void *object, size_t new_size,
>     gfp_t flags)
>{
> return (void *)object;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kasan_check_byte(const void *address)
>{
> return true;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_unpoison_task_stack(struct task_struct *task) {}
># 376 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_cache_shrink(struct kmem_cache *cache) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_cache_shutdown(struct kmem_cache *cache) {}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_record_aux_stack(void *ptr) {}
># 401 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kasan_reset_tag(const void *addr)
>{
> return (void *)addr;
>}
># 417 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_init_sw_tags(void) { }
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_init_hw_tags_cpu(void) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_init_hw_tags(void) { }
># 439 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kasan_populate_vmalloc(unsigned long start,
>     unsigned long size)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_poison_vmalloc(const void *start, unsigned long size)
>{ }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_unpoison_vmalloc(const void *start, unsigned long size)
>{ }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_release_vmalloc(unsigned long start,
>      unsigned long end,
>      unsigned long free_region_start,
>      unsigned long free_region_end) {}
># 469 "/usr/src/linux-5.14.21-150500.53/include/linux/kasan.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kasan_module_alloc(void *addr, size_t size) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_free_shadow(const struct vm_struct *vm) {}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kasan_non_canonical_hook(unsigned long addr) { }
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/memremap.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ioport.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/ioport.h"
>struct resource {
> resource_size_t start;
> resource_size_t end;
> const char *name;
> unsigned long flags;
> unsigned long desc;
> struct resource *parent, *sibling, *child;
>};
># 134 "/usr/src/linux-5.14.21-150500.53/include/linux/ioport.h"
>enum {
> IORES_DESC_NONE = 0,
> IORES_DESC_CRASH_KERNEL = 1,
> IORES_DESC_ACPI_TABLES = 2,
> IORES_DESC_ACPI_NV_STORAGE = 3,
> IORES_DESC_PERSISTENT_MEMORY = 4,
> IORES_DESC_PERSISTENT_MEMORY_LEGACY = 5,
> IORES_DESC_DEVICE_PRIVATE_MEMORY = 6,
> IORES_DESC_RESERVED = 7,
> IORES_DESC_SOFT_RESERVED = 8,
>};
>
>
>
>
>enum {
> IORES_MAP_SYSTEM_RAM = ((((1UL))) << (0)),
> IORES_MAP_ENCRYPTED = ((((1UL))) << (1)),
>};
># 185 "/usr/src/linux-5.14.21-150500.53/include/linux/ioport.h"
>extern struct resource ioport_resource;
>extern struct resource iomem_resource;
>
>extern struct resource *request_resource_conflict(struct resource *root, struct resource *new);
>extern int request_resource(struct resource *root, struct resource *new);
>extern int release_resource(struct resource *new);
>void release_child_resources(struct resource *new);
>extern void reserve_region_with_split(struct resource *root,
>        resource_size_t start, resource_size_t end,
>        const char *name);
>extern struct resource *insert_resource_conflict(struct resource *parent, struct resource *new);
>extern int insert_resource(struct resource *parent, struct resource *new);
>extern void insert_resource_expand_to_fit(struct resource *root, struct resource *new);
>extern int remove_resource(struct resource *old);
>extern void arch_remove_reservations(struct resource *avail);
>extern int allocate_resource(struct resource *root, struct resource *new,
>        resource_size_t size, 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 *lookup_resource(struct resource *root, resource_size_t start);
>int adjust_resource(struct resource *res, resource_size_t start,
>      resource_size_t size);
>resource_size_t resource_alignment(struct resource *res);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) resource_size_t resource_size(const struct resource *res)
>{
> return res->end - res->start + 1;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long resource_type(const struct resource *res)
>{
> return res->flags & 0x00001f00;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long resource_ext_type(const struct resource *res)
>{
> return res->flags & 0x01000000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool resource_contains(struct resource *r1, struct resource *r2)
>{
> if (resource_type(r1) != resource_type(r2))
>  return false;
> if (r1->flags & 0x20000000 || r2->flags & 0x20000000)
>  return false;
> return r1->start <= r2->start && r1->end >= r2->end;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool resource_overlaps(struct resource *r1, struct resource *r2)
>{
>       return r1->start <= r2->end && r1->end >= r2->start;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>resource_intersection(struct resource *r1, struct resource *r2, struct resource *r)
>{
> if (!resource_overlaps(r1, r2))
>  return false;
> r->start = __builtin_choose_expr(((!!(sizeof((typeof(r1->start) *)1 == (typeof(r2->start) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(r1->start) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(r2->start) * 0l)) : (int *)8))))), ((r1->start) > (r2->start) ? (r1->start) : (r2->start)), ({ typeof(r1->start) __UNIQUE_ID___x184 = (r1->start); typeof(r2->start) __UNIQUE_ID___y185 = (r2->start); ((__UNIQUE_ID___x184) > (__UNIQUE_ID___y185) ? (__UNIQUE_ID___x184) : (__UNIQUE_ID___y185)); }));
> r->end = __builtin_choose_expr(((!!(sizeof((typeof(r1->end) *)1 == (typeof(r2->end) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(r1->end) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(r2->end) * 0l)) : (int *)8))))), ((r1->end) < (r2->end) ? (r1->end) : (r2->end)), ({ typeof(r1->end) __UNIQUE_ID___x186 = (r1->end); typeof(r2->end) __UNIQUE_ID___y187 = (r2->end); ((__UNIQUE_ID___x186) < (__UNIQUE_ID___y187) ? (__UNIQUE_ID___x186) : (__UNIQUE_ID___y187)); }));
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>resource_union(struct resource *r1, struct resource *r2, struct resource *r)
>{
> if (!resource_overlaps(r1, r2))
>  return false;
> r->start = __builtin_choose_expr(((!!(sizeof((typeof(r1->start) *)1 == (typeof(r2->start) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(r1->start) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(r2->start) * 0l)) : (int *)8))))), ((r1->start) < (r2->start) ? (r1->start) : (r2->start)), ({ typeof(r1->start) __UNIQUE_ID___x188 = (r1->start); typeof(r2->start) __UNIQUE_ID___y189 = (r2->start); ((__UNIQUE_ID___x188) < (__UNIQUE_ID___y189) ? (__UNIQUE_ID___x188) : (__UNIQUE_ID___y189)); }));
> r->end = __builtin_choose_expr(((!!(sizeof((typeof(r1->end) *)1 == (typeof(r2->end) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(r1->end) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(r2->end) * 0l)) : (int *)8))))), ((r1->end) > (r2->end) ? (r1->end) : (r2->end)), ({ typeof(r1->end) __UNIQUE_ID___x190 = (r1->end); typeof(r2->end) __UNIQUE_ID___y191 = (r2->end); ((__UNIQUE_ID___x190) > (__UNIQUE_ID___y191) ? (__UNIQUE_ID___x190) : (__UNIQUE_ID___y191)); }));
> return true;
>}
># 271 "/usr/src/linux-5.14.21-150500.53/include/linux/ioport.h"
>extern struct resource * __request_region(struct resource *,
>     resource_size_t start,
>     resource_size_t n,
>     const char *name, int flags);
>
>
>
>
>
>extern void __release_region(struct resource *, resource_size_t,
>    resource_size_t);
>
>extern void release_mem_region_adjustable(resource_size_t, resource_size_t);
>
>
>extern void merge_system_ram_resource(struct resource *res);
>
>
>
>struct device;
>
>extern int devm_request_resource(struct device *dev, struct resource *root,
>     struct resource *new);
>extern void devm_release_resource(struct device *dev, struct resource *new);
>
>
>
>
>
>
>extern struct resource * __devm_request_region(struct device *dev,
>    struct resource *parent, resource_size_t start,
>    resource_size_t n, const char *name);
>
>
>
>
>
>
>extern void __devm_release_region(struct device *dev, struct resource *parent,
>      resource_size_t start, resource_size_t n);
>extern int iomem_map_sanity_check(resource_size_t addr, unsigned long size);
>extern bool iomem_is_exclusive(u64 addr);
>
>extern int
>walk_system_ram_range(unsigned long start_pfn, unsigned long nr_pages,
>  void *arg, int (*func)(unsigned long, unsigned long, void *));
>extern int
>walk_mem_res(u64 start, u64 end, void *arg,
>      int (*func)(struct resource *, void *));
>extern int
>walk_system_ram_res(u64 start, u64 end, void *arg,
>      int (*func)(struct resource *, void *));
>extern int
>walk_iomem_res_desc(unsigned long desc, unsigned long flags, u64 start, u64 end,
>      void *arg, int (*func)(struct resource *, void *));
>
>struct resource *devm_request_free_mem_region(struct device *dev,
>  struct resource *base, unsigned long size);
>struct resource *request_free_mem_region(struct resource *base,
>  unsigned long size, const char *name);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void irqresource_disabled(struct resource *res, u32 irq)
>{
> res->start = irq;
> res->end = irq;
> res->flags |= 0x00000400 | 0x10000000 | 0x20000000;
>}
>
>extern struct address_space *iomem_get_mapping(void);
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/memremap.h" 2
>
>
>struct resource;
>struct device;
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/memremap.h"
>struct vmem_altmap {
> unsigned long base_pfn;
> const unsigned long end_pfn;
> const unsigned long reserve;
> unsigned long free;
> unsigned long align;
> unsigned long alloc;
>};
># 68 "/usr/src/linux-5.14.21-150500.53/include/linux/memremap.h"
>enum memory_type {
>
> MEMORY_DEVICE_PRIVATE = 1,
> MEMORY_DEVICE_COHERENT,
> MEMORY_DEVICE_FS_DAX,
> MEMORY_DEVICE_GENERIC,
> MEMORY_DEVICE_PCI_P2PDMA,
>};
>
>struct dev_pagemap_ops {
>
>
>
>
>
> void (*page_free)(struct page *page);
>
>
>
>
>
> vm_fault_t (*migrate_to_ram)(struct vm_fault *vmf);
>};
># 114 "/usr/src/linux-5.14.21-150500.53/include/linux/memremap.h"
>struct dev_pagemap {
> struct vmem_altmap altmap;
> struct percpu_ref ref;
> struct completion done;
> enum memory_type type;
> unsigned int flags;
> unsigned long vmemmap_shift;
> const struct dev_pagemap_ops *ops;
> void *owner;
> int nr_range;
> union {
>  struct range range;
>  struct range ranges[0];
> };
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct vmem_altmap *pgmap_altmap(struct dev_pagemap *pgmap)
>{
> if (pgmap->flags & (1 << 0))
>  return &pgmap->altmap;
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long pgmap_vmemmap_nr(struct dev_pagemap *pgmap)
>{
> return 1 << pgmap->vmemmap_shift;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_device_private_page(const struct page *page)
>{
> return 1 &&
>  is_zone_device_page(page) &&
>  page->pgmap->type == MEMORY_DEVICE_PRIVATE;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_pci_p2pdma_page(const struct page *page)
>{
> return 1 &&
>  is_zone_device_page(page) &&
>  page->pgmap->type == MEMORY_DEVICE_PCI_P2PDMA;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_device_coherent_page(const struct page *page)
>{
> return is_zone_device_page(page) &&
>  page->pgmap->type == MEMORY_DEVICE_COHERENT;
>}
>
>
>void zone_device_page_init(struct page *page);
>void *memremap_pages(struct dev_pagemap *pgmap, int nid);
>void memunmap_pages(struct dev_pagemap *pgmap);
>void *devm_memremap_pages(struct device *dev, struct dev_pagemap *pgmap);
>void devm_memunmap_pages(struct device *dev, struct dev_pagemap *pgmap);
>struct dev_pagemap *get_dev_pagemap(unsigned long pfn,
>  struct dev_pagemap *pgmap);
>bool pgmap_pfn_valid(struct dev_pagemap *pgmap, unsigned long pfn);
>
>unsigned long vmem_altmap_offset(struct vmem_altmap *altmap);
>void vmem_altmap_free(struct vmem_altmap *altmap, unsigned long nr_pfns);
>unsigned long memremap_compat_align(void);
># 221 "/usr/src/linux-5.14.21-150500.53/include/linux/memremap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_dev_pagemap(struct dev_pagemap *pgmap)
>{
> if (pgmap)
>  percpu_ref_put(&pgmap->ref);
>}
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
>
>struct mempolicy;
>struct anon_vma;
>struct anon_vma_chain;
>struct file_ra_state;
>struct user_struct;
>struct writeback_control;
>struct bdi_writeback;
>struct pt_regs;
>
>extern int sysctl_page_lock_unfairness;
>
>void init_mm_internals(void);
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_max_mapnr(unsigned long limit) { }
>
>
>extern atomic_long_t _totalram_pages;
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long totalram_pages(void)
>{
> return (unsigned long)atomic_long_read(&_totalram_pages);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void totalram_pages_inc(void)
>{
> atomic_long_inc(&_totalram_pages);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void totalram_pages_dec(void)
>{
> atomic_long_dec(&_totalram_pages);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void totalram_pages_add(long count)
>{
> atomic_long_add(count, &_totalram_pages);
>}
>
>extern void * high_memory;
>extern int page_cluster;
>
>
>extern int sysctl_legacy_va_layout;
>
>
>
>
>
>extern const int mmap_rnd_bits_min;
>extern const int mmap_rnd_bits_max;
>extern int mmap_rnd_bits __attribute__((__section__(".data..read_mostly")));
>
>
>extern const int mmap_rnd_compat_bits_min;
>extern const int mmap_rnd_compat_bits_max;
>extern int mmap_rnd_compat_bits __attribute__((__section__(".data..read_mostly")));
># 149 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __mm_zero_struct_page(struct page *page)
>{
> unsigned long *_pp = (void *)page;
>
>
> do { extern void __compiletime_assert_192(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(struct page) & 7"))); if (!(!(sizeof(struct page) & 7))) __compiletime_assert_192(); } while (0);
> do { extern void __compiletime_assert_193(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(struct page) < 56"))); if (!(!(sizeof(struct page) < 56))) __compiletime_assert_193(); } while (0);
> do { extern void __compiletime_assert_194(void) __attribute__((__error__("BUILD_BUG_ON failed: " "sizeof(struct page) > 80"))); if (!(!(sizeof(struct page) > 80))) __compiletime_assert_194(); } while (0);
>
> switch (sizeof(struct page)) {
> case 80:
>  _pp[9] = 0;
>  __attribute__((__fallthrough__));
> case 72:
>  _pp[8] = 0;
>  __attribute__((__fallthrough__));
> case 64:
>  _pp[7] = 0;
>  __attribute__((__fallthrough__));
> case 56:
>  _pp[6] = 0;
>  _pp[5] = 0;
>  _pp[4] = 0;
>  _pp[3] = 0;
>  _pp[2] = 0;
>  _pp[1] = 0;
>  _pp[0] = 0;
> }
>}
># 201 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern int sysctl_max_map_count;
>
>extern unsigned long sysctl_user_reserve_kbytes;
>extern unsigned long sysctl_admin_reserve_kbytes;
>
>extern int sysctl_overcommit_memory;
>extern int sysctl_overcommit_ratio;
>extern unsigned long sysctl_overcommit_kbytes;
>
>int overcommit_ratio_handler(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>int overcommit_kbytes_handler(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>int overcommit_policy_handler(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>
>
>
>
>
>int __add_to_page_cache_locked(struct page *page, struct address_space *mapping,
>  unsigned long index, gfp_t gfp, void **shadowp);
># 238 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>void setup_initial_init_mm(void *start_code, void *end_code,
>      void *end_data, void *brk);
># 250 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>struct vm_area_struct *vm_area_alloc(struct mm_struct *);
>struct vm_area_struct *vm_area_dup(struct vm_area_struct *);
>void vm_area_free(struct vm_area_struct *);
># 466 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>enum fault_flag {
> FAULT_FLAG_WRITE = 1 << 0,
> FAULT_FLAG_MKWRITE = 1 << 1,
> FAULT_FLAG_ALLOW_RETRY = 1 << 2,
> FAULT_FLAG_RETRY_NOWAIT = 1 << 3,
> FAULT_FLAG_KILLABLE = 1 << 4,
> FAULT_FLAG_TRIED = 1 << 5,
> FAULT_FLAG_USER = 1 << 6,
> FAULT_FLAG_REMOTE = 1 << 7,
> FAULT_FLAG_INSTRUCTION = 1 << 8,
> FAULT_FLAG_INTERRUPTIBLE = 1 << 9,
>};
># 500 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fault_flag_allow_retry_first(enum fault_flag flags)
>{
> return (flags & FAULT_FLAG_ALLOW_RETRY) &&
>     (!(flags & FAULT_FLAG_TRIED));
>}
># 528 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>struct vm_fault {
> const struct {
>  struct vm_area_struct *vma;
>  gfp_t gfp_mask;
>  unsigned long pgoff;
>  unsigned long address;
> };
> enum fault_flag flags;
>
> pmd_t *pmd;
>
> pud_t *pud;
>
>
> union {
>  pte_t orig_pte;
>  pmd_t orig_pmd;
>
>
> };
>
> struct page *cow_page;
> struct page *page;
>
>
>
>
>
> pte_t *pte;
>
>
>
> spinlock_t *ptl;
>
>
>
> pgtable_t prealloc_pte;
>
>
>
>
>
>
>};
>
>
>enum page_entry_size {
> PE_SIZE_PTE = 0,
> PE_SIZE_PMD,
> PE_SIZE_PUD,
>};
>
>
>
>
>
>
>struct vm_operations_struct {
> void (*open)(struct vm_area_struct * area);
> void (*close)(struct vm_area_struct * area);
>
> int (*may_split)(struct vm_area_struct *area, unsigned long addr);
> int (*mremap)(struct vm_area_struct *area);
>
>
>
>
>
> int (*mprotect)(struct vm_area_struct *vma, unsigned long start,
>   unsigned long end, unsigned long newflags);
> vm_fault_t (*fault)(struct vm_fault *vmf);
> vm_fault_t (*huge_fault)(struct vm_fault *vmf,
>   enum page_entry_size pe_size);
> vm_fault_t (*map_pages)(struct vm_fault *vmf,
>   unsigned long start_pgoff, unsigned long end_pgoff);
> unsigned long (*pagesize)(struct vm_area_struct * area);
>
>
>
> vm_fault_t (*page_mkwrite)(struct vm_fault *vmf);
>
>
> vm_fault_t (*pfn_mkwrite)(struct vm_fault *vmf);
>
>
>
>
>
> int (*access)(struct vm_area_struct *vma, unsigned long addr,
>        void *buf, int len, int write);
>
>
>
>
> const char *(*name)(struct vm_area_struct *vma);
># 632 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
> int (*set_policy)(struct vm_area_struct *vma, struct mempolicy *new);
># 644 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
> struct mempolicy *(*get_policy)(struct vm_area_struct *vma,
>     unsigned long addr);
>
>
>
>
>
>
> struct page *(*find_special_page)(struct vm_area_struct *vma,
>       unsigned long addr);
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vma_init(struct vm_area_struct *vma, struct mm_struct *mm)
>{
> static const struct vm_operations_struct dummy_vm_ops = {};
>
> memset(vma, 0, sizeof(*vma));
> vma->vm_mm = mm;
> vma->vm_ops = &dummy_vm_ops;
> INIT_LIST_HEAD(&vma->anon_vma_chain);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vma_set_anonymous(struct vm_area_struct *vma)
>{
> vma->vm_ops = ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_anonymous(struct vm_area_struct *vma)
>{
> return !vma->vm_ops;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_temporary_stack(struct vm_area_struct *vma)
>{
> int maybe_stack = vma->vm_flags & (0x00000100 | 0x00000000);
>
> if (!maybe_stack)
>  return false;
>
> if ((vma->vm_flags & (0x00010000 | 0x00008000)) ==
>      (0x00010000 | 0x00008000))
>  return true;
>
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_foreign(struct vm_area_struct *vma)
>{
> if (!get_current()->mm)
>  return true;
>
> if (get_current()->mm != vma->vm_mm)
>  return true;
>
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_accessible(struct vm_area_struct *vma)
>{
> return vma->vm_flags & (0x00000001 | 0x00000002 | 0x00000004);
>}
>
>
>
>
>
>
>bool vma_is_shmem(struct vm_area_struct *vma);
>
>
>
>
>int vma_is_stack_for_current(struct vm_area_struct *vma);
>
>
>
>
>struct mmu_gather;
>struct inode;
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/coredump.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/coredump.h"
>extern void set_dumpable(struct mm_struct *mm, int value);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __get_dumpable(unsigned long mm_flags)
>{
> return mm_flags & ((1 << 2) - 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_dumpable(struct mm_struct *mm)
>{
> return __get_dumpable(mm->flags);
>}
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>struct wait_bit_key {
> void *flags;
> int bit_nr;
> unsigned long timeout;
>};
>
>struct wait_bit_queue_entry {
> struct wait_bit_key key;
> struct wait_queue_entry wq_entry;
>};
>
>
>
>
>typedef int wait_bit_action_f(struct wait_bit_key *key, int mode);
>
>void __wake_up_bit(struct wait_queue_head *wq_head, void *word, int bit);
>int __wait_on_bit(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode);
>int __wait_on_bit_lock(struct wait_queue_head *wq_head, struct wait_bit_queue_entry *wbq_entry, wait_bit_action_f *action, unsigned int mode);
>void wake_up_bit(void *word, int bit);
>int out_of_line_wait_on_bit(void *word, int, wait_bit_action_f *action, unsigned int mode);
>int out_of_line_wait_on_bit_timeout(void *word, int, wait_bit_action_f *action, unsigned int mode, unsigned long timeout);
>int out_of_line_wait_on_bit_lock(void *word, int, wait_bit_action_f *action, unsigned int mode);
>struct wait_queue_head *bit_waitqueue(void *word, int bit);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) wait_bit_init(void);
>
>int wake_bit_function(struct wait_queue_entry *wq_entry, unsigned mode, int sync, void *key);
># 49 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>extern int bit_wait(struct wait_bit_key *key, int mode);
>extern int bit_wait_io(struct wait_bit_key *key, int mode);
>extern int bit_wait_timeout(struct wait_bit_key *key, int mode);
>extern int bit_wait_io_timeout(struct wait_bit_key *key, int mode);
># 70 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit(unsigned long *word, int bit, unsigned mode)
>{
> do { might_resched(); } while (0);
> if (!test_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit(word, bit,
>           bit_wait,
>           mode);
>}
># 95 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit_io(unsigned long *word, int bit, unsigned mode)
>{
> do { might_resched(); } while (0);
> if (!test_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit(word, bit,
>           bit_wait_io,
>           mode);
>}
># 121 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit_timeout(unsigned long *word, int bit, unsigned mode,
>      unsigned long timeout)
>{
> do { might_resched(); } while (0);
> if (!test_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit_timeout(word, bit,
>            bit_wait_timeout,
>            mode, timeout);
>}
># 149 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit_action(unsigned long *word, int bit, wait_bit_action_f *action,
>     unsigned mode)
>{
> do { might_resched(); } while (0);
> if (!test_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit(word, bit, action, mode);
>}
># 178 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit_lock(unsigned long *word, int bit, unsigned mode)
>{
> do { might_resched(); } while (0);
> if (!test_and_set_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit_lock(word, bit, bit_wait, mode);
>}
># 202 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit_lock_io(unsigned long *word, int bit, unsigned mode)
>{
> do { might_resched(); } while (0);
> if (!test_and_set_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit_lock(word, bit, bit_wait_io, mode);
>}
># 228 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>wait_on_bit_lock_action(unsigned long *word, int bit, wait_bit_action_f *action,
>   unsigned mode)
>{
> do { might_resched(); } while (0);
> if (!test_and_set_bit(bit, word))
>  return 0;
> return out_of_line_wait_on_bit_lock(word, bit, action, mode);
>}
>
>extern void init_wait_var_entry(struct wait_bit_queue_entry *wbq_entry, void *var, int flags);
>extern void wake_up_var(void *var);
>extern wait_queue_head_t *__var_waitqueue(void *p);
># 330 "/usr/src/linux-5.14.21-150500.53/include/linux/wait_bit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_and_wake_up_bit(int bit, void *word)
>{
> clear_bit_unlock(bit, word);
>
> do { } while (0);
> wake_up_bit(word, bit);
>}
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kdev_t.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/kdev_t.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/kdev_t.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/kdev_t.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool old_valid_dev(dev_t dev)
>{
> return ((unsigned int) ((dev) >> 20)) < 256 && ((unsigned int) ((dev) & ((1U << 20) - 1))) < 256;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u16 old_encode_dev(dev_t dev)
>{
> return (((unsigned int) ((dev) >> 20)) << 8) | ((unsigned int) ((dev) & ((1U << 20) - 1)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) dev_t old_decode_dev(u16 val)
>{
> return ((((val >> 8) & 255) << 20) | (val & 255));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u32 new_encode_dev(dev_t dev)
>{
> unsigned major = ((unsigned int) ((dev) >> 20));
> unsigned minor = ((unsigned int) ((dev) & ((1U << 20) - 1)));
> return (minor & 0xff) | (major << 8) | ((minor & ~0xff) << 12);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) dev_t new_decode_dev(u32 dev)
>{
> unsigned major = (dev & 0xfff00) >> 8;
> unsigned minor = (dev & 0xff) | ((dev >> 12) & 0xfff00);
> return (((major) << 20) | (minor));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u64 huge_encode_dev(dev_t dev)
>{
> return new_encode_dev(dev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) dev_t huge_decode_dev(u64 dev)
>{
> return new_decode_dev(dev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int sysv_valid_dev(dev_t dev)
>{
> return ((unsigned int) ((dev) >> 20)) < (1<<14) && ((unsigned int) ((dev) & ((1U << 20) - 1))) < (1<<18);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u32 sysv_encode_dev(dev_t dev)
>{
> return ((unsigned int) ((dev) & ((1U << 20) - 1))) | (((unsigned int) ((dev) >> 20)) << 18);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned sysv_major(u32 dev)
>{
> return (dev >> 18) & 0x3fff;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned sysv_minor(u32 dev)
>{
> return dev & 0x3ffff;
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist_bl.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/list_bl.h" 1
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/list_bl.h"
>struct hlist_bl_head {
> struct hlist_bl_node *first;
>};
>
>struct hlist_bl_node {
> struct hlist_bl_node *next, **pprev;
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void INIT_HLIST_BL_NODE(struct hlist_bl_node *h)
>{
> h->next = ((void *)0);
> h->pprev = ((void *)0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool hlist_bl_unhashed(const struct hlist_bl_node *h)
>{
> return !h->pprev;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct hlist_bl_node *hlist_bl_first(struct hlist_bl_head *h)
>{
> return (struct hlist_bl_node *)
>  ((unsigned long)h->first & ~1UL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_set_first(struct hlist_bl_head *h,
>     struct hlist_bl_node *n)
>{
> ;
>
>                        ;
> h->first = (struct hlist_bl_node *)((unsigned long)n | 1UL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool hlist_bl_empty(const struct hlist_bl_head *h)
>{
> return !((unsigned long)({ do { extern void __compiletime_assert_195(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(h->first) == sizeof(char) || sizeof(h->first) == sizeof(short) || sizeof(h->first) == sizeof(int) || sizeof(h->first) == sizeof(long)) || sizeof(h->first) == sizeof(long long))) __compiletime_assert_195(); } while (0); (*(const volatile typeof( _Generic((h->first), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (h->first))) *)&(h->first)); }) & ~1UL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_add_head(struct hlist_bl_node *n,
>     struct hlist_bl_head *h)
>{
> struct hlist_bl_node *first = hlist_bl_first(h);
>
> n->next = first;
> if (first)
>  first->pprev = &n->next;
> n->pprev = &h->first;
> hlist_bl_set_first(h, n);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_add_before(struct hlist_bl_node *n,
>           struct hlist_bl_node *next)
>{
> struct hlist_bl_node **pprev = next->pprev;
>
> n->pprev = pprev;
> n->next = next;
> next->pprev = &n->next;
>
>
> do { do { extern void __compiletime_assert_196(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pprev) == sizeof(char) || sizeof(*pprev) == sizeof(short) || sizeof(*pprev) == sizeof(int) || sizeof(*pprev) == sizeof(long)) || sizeof(*pprev) == sizeof(long long))) __compiletime_assert_196(); } while (0); do { *(volatile typeof(*pprev) *)&(*pprev) = ((struct hlist_bl_node *) ((uintptr_t)n | ((uintptr_t)*pprev & 1UL))); } while (0); } while (0)
>
>                                                           ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_add_behind(struct hlist_bl_node *n,
>           struct hlist_bl_node *prev)
>{
> n->next = prev->next;
> n->pprev = &prev->next;
> prev->next = n;
>
> if (n->next)
>  n->next->pprev = &n->next;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __hlist_bl_del(struct hlist_bl_node *n)
>{
> struct hlist_bl_node *next = n->next;
> struct hlist_bl_node **pprev = n->pprev;
>
> ;
>
>
> do { do { extern void __compiletime_assert_197(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*pprev) == sizeof(char) || sizeof(*pprev) == sizeof(short) || sizeof(*pprev) == sizeof(int) || sizeof(*pprev) == sizeof(long)) || sizeof(*pprev) == sizeof(long long))) __compiletime_assert_197(); } while (0); do { *(volatile typeof(*pprev) *)&(*pprev) = ((struct hlist_bl_node *) ((unsigned long)next | ((unsigned long)*pprev & 1UL))); } while (0); } while (0)
>
>
>                                                ;
> if (next)
>  next->pprev = pprev;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_del(struct hlist_bl_node *n)
>{
> __hlist_bl_del(n);
> n->next = ((void *) 0x100 + (0xdead000000000000UL));
> n->pprev = ((void *) 0x122 + (0xdead000000000000UL));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_del_init(struct hlist_bl_node *n)
>{
> if (!hlist_bl_unhashed(n)) {
>  __hlist_bl_del(n);
>  INIT_HLIST_BL_NODE(n);
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_lock(struct hlist_bl_head *b)
>{
> bit_spin_lock(0, (unsigned long *)b);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_unlock(struct hlist_bl_head *b)
>{
> __bit_spin_unlock(0, (unsigned long *)b);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool hlist_bl_is_locked(struct hlist_bl_head *b)
>{
> return bit_spin_is_locked(0, (unsigned long *)b);
>}
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist_bl.h" 2
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_set_first_rcu(struct hlist_bl_head *h,
>     struct hlist_bl_node *n)
>{
> ;
>
>                        ;
> do { uintptr_t _r_a_p__v = (uintptr_t)((struct hlist_bl_node *)((unsigned long)n | 1UL)); ; if (__builtin_constant_p((struct hlist_bl_node *)((unsigned long)n | 1UL)) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_198(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((h->first)) == sizeof(char) || sizeof((h->first)) == sizeof(short) || sizeof((h->first)) == sizeof(int) || sizeof((h->first)) == sizeof(long)) || sizeof((h->first)) == sizeof(long long))) __compiletime_assert_198(); } while (0); do { *(volatile typeof((h->first)) *)&((h->first)) = ((typeof(h->first))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_199(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&h->first) == sizeof(char) || sizeof(*&h->first) == sizeof(short) || sizeof(*&h->first) == sizeof(int) || sizeof(*&h->first) == sizeof(long)))) __compiletime_assert_199(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_200(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&h->first) == sizeof(char) || sizeof(*&h->first) == sizeof(short) || sizeof(*&h->first) == sizeof(int) || sizeof(*&h->first) == sizeof(long)) || sizeof(*&h->first) == sizeof(long long))) __compiletime_assert_200(); } while (0); do { *(volatile typeof(*&h->first) *)&(*&h->first) = ((typeof(*((typeof(h->first))_r_a_p__v)) *)((typeof(h->first))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0)
>                                                                ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct hlist_bl_node *hlist_bl_first_rcu(struct hlist_bl_head *h)
>{
> return (struct hlist_bl_node *)
>  ((unsigned long)({ typeof(*(h->first)) *________p1 = (typeof(*(h->first)) *)({ do { extern void __compiletime_assert_201(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((h->first)) == sizeof(char) || sizeof((h->first)) == sizeof(short) || sizeof((h->first)) == sizeof(int) || sizeof((h->first)) == sizeof(long)) || sizeof((h->first)) == sizeof(long long))) __compiletime_assert_201(); } while (0); (*(const volatile typeof( _Generic(((h->first)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((h->first)))) *)&((h->first))); }); do { } while (0 && (!((hlist_bl_is_locked(h)) || rcu_read_lock_held()))); ; ((typeof(*(h->first)) *)(________p1)); }) & ~1UL);
>}
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist_bl.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_del_rcu(struct hlist_bl_node *n)
>{
> __hlist_bl_del(n);
> n->pprev = ((void *) 0x122 + (0xdead000000000000UL));
>}
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/rculist_bl.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void hlist_bl_add_head_rcu(struct hlist_bl_node *n,
>     struct hlist_bl_head *h)
>{
> struct hlist_bl_node *first;
>
>
> first = hlist_bl_first(h);
>
> n->next = first;
> if (first)
>  first->pprev = &n->next;
> n->pprev = &h->first;
>
>
> hlist_bl_set_first_rcu(h, n);
>}
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/lockref.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/lockref.h"
>struct lockref {
> union {
>
>  __u64 __attribute__((aligned(8))) lock_count;
>
>  struct {
>   spinlock_t lock;
>   int count;
>  };
> };
>};
>
>extern void lockref_get(struct lockref *);
>extern int lockref_put_return(struct lockref *);
>extern int lockref_get_not_zero(struct lockref *);
>extern int lockref_put_not_zero(struct lockref *);
>extern int lockref_get_or_lock(struct lockref *);
>extern int lockref_put_or_lock(struct lockref *);
>
>extern void lockref_mark_dead(struct lockref *);
>extern int lockref_get_not_dead(struct lockref *);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __lockref_is_dead(const struct lockref *l)
>{
> return ((int)l->count < 0);
>}
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stringhash.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/hash.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/hash.h" 2
># 60 "/usr/src/linux-5.14.21-150500.53/include/linux/hash.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 __hash_32_generic(u32 val)
>{
> return val * 0x61C88647;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 hash_32(u32 val, unsigned int bits)
>{
>
> return __hash_32_generic(val) >> (32 - bits);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) u32 hash_64_generic(u64 val, unsigned int bits)
>{
>
>
> return val * 0x61C8864680B583EBull >> (64 - bits);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 hash_ptr(const void *ptr, unsigned int bits)
>{
> return hash_64_generic((unsigned long)ptr, bits);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 hash32_ptr(const void *ptr)
>{
> unsigned long val = (unsigned long)ptr;
>
>
> val ^= (val >> 32);
>
> return (u32)val;
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/stringhash.h" 2
># 42 "/usr/src/linux-5.14.21-150500.53/include/linux/stringhash.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>partial_name_hash(unsigned long c, unsigned long prevhash)
>{
> return (prevhash + (c << 4) + (c >> 4)) * 11;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int end_name_hash(unsigned long hash)
>{
> return hash_64_generic(hash, 32);
>}
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/stringhash.h"
>extern unsigned int __attribute__((__pure__)) full_name_hash(const void *salt, const char *, unsigned int);
># 77 "/usr/src/linux-5.14.21-150500.53/include/linux/stringhash.h"
>extern u64 __attribute__((__pure__)) hashlen_string(const void *salt, const char *name);
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h" 2
>
>
>struct path;
>struct vfsmount;
># 48 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>struct qstr {
> union {
>  struct {
>   u32 hash; u32 len;
>  };
>  u64 hash_len;
> };
> const unsigned char *name;
>};
>
>
>
>extern const struct qstr empty_name;
>extern const struct qstr slash_name;
>extern const struct qstr dotdot_name;
>
>struct dentry_stat_t {
> long nr_dentry;
> long nr_unused;
> long age_limit;
> long want_pages;
> long nr_negative;
> long dummy;
>};
>extern struct dentry_stat_t dentry_stat;
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>struct dentry {
>
> unsigned int d_flags;
> seqcount_spinlock_t d_seq;
> struct hlist_bl_node d_hash;
> struct dentry *d_parent;
> struct qstr d_name;
> struct inode *d_inode;
>
> unsigned char d_iname[32];
>
>
> struct lockref d_lockref;
> const struct dentry_operations *d_op;
> struct super_block *d_sb;
> unsigned long 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;
>} __attribute__((__designated_init__));
>
>
>
>
>
>
>
>enum dentry_d_lock_class
>{
> DENTRY_D_LOCK_NORMAL,
> DENTRY_D_LOCK_NESTED
>};
>
>struct dentry_operations {
> 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 *,
>   unsigned int, const char *, const struct qstr *);
> int (*d_delete)(const struct dentry *);
> int (*d_init)(struct dentry *);
> void (*d_release)(struct dentry *);
> void (*d_prune)(struct dentry *);
> void (*d_iput)(struct dentry *, struct inode *);
> char *(*d_dname)(struct dentry *, char *, int);
> struct vfsmount *(*d_automount)(struct path *);
> int (*d_manage)(const struct path *, bool);
> struct dentry *(*d_real)(struct dentry *, const struct inode *);
>} __attribute__((__aligned__((1 << (6)))));
># 225 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>extern seqlock_t rename_lock;
>
>
>
>
>extern void d_instantiate(struct dentry *, struct inode *);
>extern void d_instantiate_new(struct dentry *, struct inode *);
>extern struct dentry * d_instantiate_unique(struct dentry *, struct inode *);
>extern struct dentry * d_instantiate_anon(struct dentry *, struct inode *);
>extern void __d_drop(struct dentry *dentry);
>extern void d_drop(struct dentry *dentry);
>extern void d_delete(struct dentry *);
>extern void d_set_d_op(struct dentry *dentry, const struct dentry_operations *op);
>
>
>extern struct dentry * d_alloc(struct dentry *, const struct qstr *);
>extern struct dentry * d_alloc_anon(struct super_block *);
>extern struct dentry * d_alloc_parallel(struct dentry *, const struct qstr *,
>     wait_queue_head_t *);
>extern struct dentry * d_splice_alias(struct inode *, struct dentry *);
>extern struct dentry * d_add_ci(struct dentry *, struct inode *, struct qstr *);
>extern bool d_same_name(const struct dentry *dentry, const struct dentry *parent,
>   const struct qstr *name);
>extern struct dentry * d_exact_alias(struct dentry *, struct inode *);
>extern struct dentry *d_find_any_alias(struct inode *inode);
>extern struct dentry * d_obtain_alias(struct inode *);
>extern struct dentry * d_obtain_root(struct inode *);
>extern void shrink_dcache_sb(struct super_block *);
>extern void shrink_dcache_parent(struct dentry *);
>extern void shrink_dcache_for_umount(struct super_block *);
>extern void d_invalidate(struct dentry *);
>
>
>extern struct dentry * d_make_root(struct inode *);
>
>
>extern void d_genocide(struct dentry *);
>
>extern void d_tmpfile(struct dentry *, struct inode *);
>
>extern struct dentry *d_find_alias(struct inode *);
>extern void d_prune_aliases(struct inode *);
>
>extern struct dentry *d_find_alias_rcu(struct inode *);
>
>
>extern int path_has_submounts(const struct path *);
>
>
>
>
>extern void d_rehash(struct dentry *);
>
>extern void d_add(struct dentry *, struct inode *);
>
>
>extern void d_move(struct dentry *, struct dentry *);
>extern void d_exchange(struct dentry *, struct dentry *);
>extern struct dentry *d_ancestor(struct dentry *, struct dentry *);
>
>
>extern struct dentry *d_lookup(const struct dentry *, const struct qstr *);
>extern struct dentry *d_hash_and_lookup(struct dentry *, struct qstr *);
>extern struct dentry *__d_lookup(const struct dentry *, const struct qstr *);
>extern struct dentry *__d_lookup_rcu(const struct dentry *parent,
>    const struct qstr *name, unsigned *seq);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned d_count(const struct dentry *dentry)
>{
> return dentry->d_lockref.count;
>}
>
>
>
>
>extern __attribute__((__format__(printf, 4, 5)))
>char *dynamic_dname(struct dentry *, char *, int, const char *, ...);
>
>extern char *__d_path(const struct path *, const struct path *, char *, int);
>extern char *d_absolute_path(const struct path *, char *, int);
>extern char *d_path(const struct path *, char *, int);
>extern char *dentry_path_raw(const struct dentry *, char *, int);
>extern char *dentry_path(const struct dentry *, char *, int);
># 319 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct dentry *dget_dlock(struct dentry *dentry)
>{
> if (dentry)
>  dentry->d_lockref.count++;
> return dentry;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct dentry *dget(struct dentry *dentry)
>{
> if (dentry)
>  lockref_get(&dentry->d_lockref);
> return dentry;
>}
>
>extern struct dentry *dget_parent(struct dentry *dentry);
># 342 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int d_unhashed(const struct dentry *dentry)
>{
> return hlist_bl_unhashed(&dentry->d_hash);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int d_unlinked(const struct dentry *dentry)
>{
> return d_unhashed(dentry) && !((dentry) == (dentry)->d_parent);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cant_mount(const struct dentry *dentry)
>{
> return (dentry->d_flags & 0x00000100);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dont_mount(struct dentry *dentry)
>{
> spin_lock(&dentry->d_lockref.lock);
> dentry->d_flags |= 0x00000100;
> spin_unlock(&dentry->d_lockref.lock);
>}
>
>extern void __d_lookup_done(struct dentry *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int d_in_lookup(const struct dentry *dentry)
>{
> return dentry->d_flags & 0x10000000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void d_lookup_done(struct dentry *dentry)
>{
> if (__builtin_expect(!!(d_in_lookup(dentry)), 0)) {
>  spin_lock(&dentry->d_lockref.lock);
>  __d_lookup_done(dentry);
>  spin_unlock(&dentry->d_lockref.lock);
> }
>}
>
>extern void dput(struct dentry *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_managed(const struct dentry *dentry)
>{
> return dentry->d_flags & (0x00010000|0x00020000|0x00040000);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_mountpoint(const struct dentry *dentry)
>{
> return dentry->d_flags & 0x00010000;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned __d_entry_type(const struct dentry *dentry)
>{
> return dentry->d_flags & 0x00700000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_miss(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00000000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_whiteout(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00100000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_can_lookup(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00200000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_autodir(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00300000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_dir(const struct dentry *dentry)
>{
> return d_can_lookup(dentry) || d_is_autodir(dentry);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_symlink(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00600000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_reg(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00400000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_special(const struct dentry *dentry)
>{
> return __d_entry_type(dentry) == 0x00500000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_file(const struct dentry *dentry)
>{
> return d_is_reg(dentry) || d_is_special(dentry);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_negative(const struct dentry *dentry)
>{
>
> return d_is_miss(dentry);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_flags_negative(unsigned flags)
>{
> return (flags & 0x00700000) == 0x00000000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_positive(const struct dentry *dentry)
>{
> return !d_is_negative(dentry);
>}
># 476 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_really_is_negative(const struct dentry *dentry)
>{
> return dentry->d_inode == ((void *)0);
>}
># 494 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_really_is_positive(const struct dentry *dentry)
>{
> return dentry->d_inode != ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int simple_positive(const struct dentry *dentry)
>{
> return d_really_is_positive(dentry) && !d_unhashed(dentry);
>}
>
>extern void d_set_fallthru(struct dentry *dentry);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool d_is_fallthru(const struct dentry *dentry)
>{
> return dentry->d_flags & 0x01000000;
>}
>
>
>extern int sysctl_vfs_cache_pressure;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long vfs_pressure_ratio(unsigned long val)
>{
> return ( { typeof(val) quot = (val) / (100); typeof(val) rem = (val) % (100); (quot * (sysctl_vfs_cache_pressure)) + ((rem * (sysctl_vfs_cache_pressure)) / (100)); } );
>}
># 526 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct inode *d_inode(const struct dentry *dentry)
>{
> return dentry->d_inode;
>}
># 538 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct inode *d_inode_rcu(const struct dentry *dentry)
>{
> return ({ do { extern void __compiletime_assert_202(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(dentry->d_inode) == sizeof(char) || sizeof(dentry->d_inode) == sizeof(short) || sizeof(dentry->d_inode) == sizeof(int) || sizeof(dentry->d_inode) == sizeof(long)) || sizeof(dentry->d_inode) == sizeof(long long))) __compiletime_assert_202(); } while (0); (*(const volatile typeof( _Generic((dentry->d_inode), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (dentry->d_inode))) *)&(dentry->d_inode)); });
>}
># 553 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct inode *d_backing_inode(const struct dentry *upper)
>{
> struct inode *inode = upper->d_inode;
>
> return inode;
>}
># 570 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct dentry *d_backing_dentry(struct dentry *upper)
>{
> return upper;
>}
># 585 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct dentry *d_real(struct dentry *dentry,
>        const struct inode *inode)
>{
> if (__builtin_expect(!!(dentry->d_flags & 0x04000000), 0))
>  return dentry->d_op->d_real(dentry, inode);
> else
>  return dentry;
>}
># 601 "/usr/src/linux-5.14.21-150500.53/include/linux/dcache.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct inode *d_real_inode(const struct dentry *dentry)
>{
>
> return d_backing_inode(d_real((struct dentry *) dentry, ((void *)0)));
>}
>
>struct name_snapshot {
> struct qstr name;
> unsigned char inline_name[32];
>};
>void take_dentry_name_snapshot(struct name_snapshot *, struct dentry *);
>void release_dentry_name_snapshot(struct name_snapshot *);
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/path.h" 1
>
>
>
>
>struct dentry;
>struct vfsmount;
>
>struct path {
> struct vfsmount *mnt;
> struct dentry *dentry;
>} __attribute__((__designated_init__));
>
>extern void path_get(const struct path *);
>extern void path_put(const struct path *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int path_equal(const struct path *path1, const struct path *path2)
>{
> return path1->mnt == path2->mnt && path1->dentry == path2->dentry;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void path_put_init(struct path *path)
>{
> path_put(path);
> *path = (struct path) { };
>}
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/stat.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/stat.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/posix_types.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/stat.h" 2
># 83 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/stat.h"
>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];
>};
># 117 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/uapi/asm/stat.h"
>struct __old_kernel_stat {
> unsigned short st_dev;
> unsigned short st_ino;
> unsigned short st_mode;
> unsigned short st_nlink;
> unsigned short st_uid;
> unsigned short st_gid;
> unsigned short st_rdev;
>
>
>
>
>
>
> unsigned int st_size;
> unsigned int st_atime;
> unsigned int st_mtime;
> unsigned int st_ctime;
>
>};
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/stat.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/stat.h" 1
># 56 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/stat.h"
>struct statx_timestamp {
> __s64 tv_sec;
> __u32 tv_nsec;
> __s32 __reserved;
>};
># 99 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/stat.h"
>struct statx {
>
> __u32 stx_mask;
> __u32 stx_blksize;
> __u64 stx_attributes;
>
> __u32 stx_nlink;
> __u32 stx_uid;
> __u32 stx_gid;
> __u16 stx_mode;
> __u16 __spare0[1];
>
> __u64 stx_ino;
> __u64 stx_size;
> __u64 stx_blocks;
> __u64 stx_attributes_mask;
>
> struct statx_timestamp stx_atime;
> struct statx_timestamp stx_btime;
> struct statx_timestamp stx_ctime;
> struct statx_timestamp stx_mtime;
>
> __u32 stx_rdev_major;
> __u32 stx_rdev_minor;
> __u32 stx_dev_major;
> __u32 stx_dev_minor;
>
> __u64 stx_mnt_id;
> __u64 __spare2;
>
> __u64 __spare3[12];
>
>};
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/stat.h" 2
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/stat.h"
>struct kstat {
> u32 result_mask;
> umode_t mode;
> unsigned int nlink;
> uint32_t blksize;
> u64 attributes;
> u64 attributes_mask;
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/stat.h"
> u64 ino;
> dev_t dev;
> dev_t rdev;
> kuid_t uid;
> kgid_t gid;
> loff_t size;
> struct timespec64 atime;
> struct timespec64 mtime;
> struct timespec64 ctime;
> struct timespec64 btime;
> u64 blocks;
> u64 mnt_id;
>};
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>struct mem_cgroup;
>
>
>enum lru_status {
> LRU_REMOVED,
> LRU_REMOVED_RETRY,
>
> LRU_ROTATE,
> LRU_SKIP,
> LRU_RETRY,
>
>};
>
>struct list_lru_one {
> struct list_head list;
>
> long nr_items;
>};
>
>struct list_lru_memcg {
> struct callback_head rcu;
>
> struct list_lru_one *lru[];
>};
>
>struct list_lru_node {
>
> spinlock_t lock;
>
> struct list_lru_one lru;
>
>
> struct list_lru_memcg *memcg_lrus;
>
> long nr_items;
>} __attribute__((__aligned__((1 << (6)))));
>
>struct list_lru {
> struct list_lru_node *node;
>
> struct list_head list;
> int shrinker_id;
> bool memcg_aware;
>
>};
>
>void list_lru_destroy(struct list_lru *lru);
>int __list_lru_init(struct list_lru *lru, bool memcg_aware,
>      struct lock_class_key *key, struct shrinker *shrinker);
># 72 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>int memcg_update_all_list_lrus(int num_memcgs);
>void memcg_drain_all_list_lrus(int src_idx, struct mem_cgroup *dst_memcg);
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>bool list_lru_add(struct list_lru *lru, struct list_head *item);
># 104 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>bool list_lru_del(struct list_lru *lru, struct list_head *item);
># 116 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>unsigned long list_lru_count_one(struct list_lru *lru,
>     int nid, struct mem_cgroup *memcg);
>unsigned long list_lru_count_node(struct list_lru *lru, int nid);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long list_lru_shrink_count(struct list_lru *lru,
>        struct shrink_control *sc)
>{
> return list_lru_count_one(lru, sc->nid, sc->memcg);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long list_lru_count(struct list_lru *lru)
>{
> long count = 0;
> int nid;
>
> for (((nid)) = __first_node(&(node_states[N_NORMAL_MEMORY])); ((nid)) < (1 << 10); ((nid)) = __next_node((((nid))), &((node_states[N_NORMAL_MEMORY]))))
>  count += list_lru_count_node(lru, nid);
>
> return count;
>}
>
>void list_lru_isolate(struct list_lru_one *list, struct list_head *item);
>void list_lru_isolate_move(struct list_lru_one *list, struct list_head *item,
>      struct list_head *head);
>
>typedef enum lru_status (*list_lru_walk_cb)(struct list_head *item,
>  struct list_lru_one *list, spinlock_t *lock, void *cb_arg);
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>unsigned long list_lru_walk_one(struct list_lru *lru,
>    int nid, struct mem_cgroup *memcg,
>    list_lru_walk_cb isolate, void *cb_arg,
>    unsigned long *nr_to_walk);
># 183 "/usr/src/linux-5.14.21-150500.53/include/linux/list_lru.h"
>unsigned long list_lru_walk_one_irq(struct list_lru *lru,
>        int nid, struct mem_cgroup *memcg,
>        list_lru_walk_cb isolate, void *cb_arg,
>        unsigned long *nr_to_walk);
>unsigned long list_lru_walk_node(struct list_lru *lru, int nid,
>     list_lru_walk_cb isolate, void *cb_arg,
>     unsigned long *nr_to_walk);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>list_lru_shrink_walk(struct list_lru *lru, struct shrink_control *sc,
>       list_lru_walk_cb isolate, void *cb_arg)
>{
> return list_lru_walk_one(lru, sc->nid, sc->memcg, isolate, cb_arg,
>     &sc->nr_to_scan);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>list_lru_shrink_walk_irq(struct list_lru *lru, struct shrink_control *sc,
>    list_lru_walk_cb isolate, void *cb_arg)
>{
> return list_lru_walk_one_irq(lru, sc->nid, sc->memcg, isolate, cb_arg,
>         &sc->nr_to_scan);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>list_lru_walk(struct list_lru *lru, list_lru_walk_cb isolate,
>       void *cb_arg, unsigned long nr_to_walk)
>{
> long isolated = 0;
> int nid;
>
> for (((nid)) = __first_node(&(node_states[N_NORMAL_MEMORY])); ((nid)) < (1 << 10); ((nid)) = __next_node((((nid))), &((node_states[N_NORMAL_MEMORY])))) {
>  isolated += list_lru_walk_node(lru, nid, isolate,
>            cb_arg, &nr_to_walk);
>  if (nr_to_walk <= 0)
>   break;
> }
> return isolated;
>}
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kconfig.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h" 2
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_mk_value(unsigned long v)
>{
> ({ int __ret_warn_on = !!((long)v < 0); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"), "i" (54), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("203" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "203" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return (void *)((v << 1) | 1);
>}
># 65 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long xa_to_value(const void *entry)
>{
> return (unsigned long)entry >> 1;
>}
># 77 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_value(const void *entry)
>{
> return (unsigned long)entry & 1;
>}
># 95 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_tag_pointer(void *p, unsigned long tag)
>{
> return (void *)((unsigned long)p | tag);
>}
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_untag_pointer(void *entry)
>{
> return (void *)((unsigned long)entry & ~3UL);
>}
># 125 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int xa_pointer_tag(void *entry)
>{
> return (unsigned long)entry & 3UL;
>}
># 143 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_mk_internal(unsigned long v)
>{
> return (void *)((v << 2) | 2);
>}
># 155 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long xa_to_internal(const void *entry)
>{
> return (unsigned long)entry >> 2;
>}
># 167 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_internal(const void *entry)
>{
> return ((unsigned long)entry & 3) == 2;
>}
># 183 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_zero(const void *entry)
>{
> return __builtin_expect(!!(entry == xa_mk_internal(257)), 0);
>}
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_err(const void *entry)
>{
> return __builtin_expect(!!(xa_is_internal(entry) && entry >= xa_mk_internal(-4095)), 0)
>                                       ;
>}
># 217 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int xa_err(void *entry)
>{
>
> if (xa_is_err(entry))
>  return (long)entry >> 2;
> return 0;
>}
># 237 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>struct xa_limit {
> u32 max;
> u32 min;
>};
>
>
>
>
>
>
>
>typedef unsigned xa_mark_t;
>
>
>
>
>
>
>
>enum xa_lock_type {
> XA_LOCK_IRQ = 1,
> XA_LOCK_BH = 2,
>};
># 294 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>struct xarray {
> spinlock_t xa_lock;
>
> gfp_t xa_flags;
> void * xa_head;
>};
># 349 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>void *xa_load(struct xarray *, unsigned long index);
>void *xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
>void *xa_erase(struct xarray *, unsigned long index);
>void *xa_store_range(struct xarray *, unsigned long first, unsigned long last,
>   void *entry, gfp_t);
>bool xa_get_mark(struct xarray *, unsigned long index, xa_mark_t);
>void xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
>void xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
>void *xa_find(struct xarray *xa, unsigned long *index,
>  unsigned long max, xa_mark_t) __attribute__((nonnull(2)));
>void *xa_find_after(struct xarray *xa, unsigned long *index,
>  unsigned long max, xa_mark_t) __attribute__((nonnull(2)));
>unsigned int xa_extract(struct xarray *, void **dst, unsigned long start,
>  unsigned long max, unsigned int n, xa_mark_t);
>void xa_destroy(struct xarray *);
># 376 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xa_init_flags(struct xarray *xa, gfp_t flags)
>{
> do { spinlock_check(&xa->xa_lock); *(&xa->xa_lock) = (spinlock_t) { { .rlock = { .raw_lock = { { .val = { (0) } } }, } } }; } while (0);
> xa->xa_flags = flags;
> xa->xa_head = ((void *)0);
>}
># 391 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xa_init(struct xarray *xa)
>{
> xa_init_flags(xa, 0);
>}
># 403 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_empty(const struct xarray *xa)
>{
> return xa->xa_head == ((void *)0);
>}
># 416 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_marked(const struct xarray *xa, xa_mark_t mark)
>{
> return xa->xa_flags & (( gfp_t)((1U << (25 + 0)) << ( unsigned)(mark)));
>}
># 556 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>void *__xa_erase(struct xarray *, unsigned long index);
>void *__xa_store(struct xarray *, unsigned long index, void *entry, gfp_t);
>void *__xa_cmpxchg(struct xarray *, unsigned long index, void *old,
>  void *entry, gfp_t);
>int __attribute__((__warn_unused_result__)) __xa_insert(struct xarray *, unsigned long index,
>  void *entry, gfp_t);
>int __attribute__((__warn_unused_result__)) __xa_alloc(struct xarray *, u32 *id, void *entry,
>  struct xa_limit, gfp_t);
>int __attribute__((__warn_unused_result__)) __xa_alloc_cyclic(struct xarray *, u32 *id, void *entry,
>  struct xa_limit, u32 *next, gfp_t);
>void __xa_set_mark(struct xarray *, unsigned long index, xa_mark_t);
>void __xa_clear_mark(struct xarray *, unsigned long index, xa_mark_t);
># 583 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_store_bh(struct xarray *xa, unsigned long index,
>  void *entry, gfp_t gfp)
>{
> void *curr;
>
> spin_lock_bh(&(xa)->xa_lock);
> curr = __xa_store(xa, index, entry, gfp);
> spin_unlock_bh(&(xa)->xa_lock);
>
> return curr;
>}
># 609 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_store_irq(struct xarray *xa, unsigned long index,
>  void *entry, gfp_t gfp)
>{
> void *curr;
>
> spin_lock_irq(&(xa)->xa_lock);
> curr = __xa_store(xa, index, entry, gfp);
> spin_unlock_irq(&(xa)->xa_lock);
>
> return curr;
>}
># 634 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_erase_bh(struct xarray *xa, unsigned long index)
>{
> void *entry;
>
> spin_lock_bh(&(xa)->xa_lock);
> entry = __xa_erase(xa, index);
> spin_unlock_bh(&(xa)->xa_lock);
>
> return entry;
>}
># 658 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_erase_irq(struct xarray *xa, unsigned long index)
>{
> void *entry;
>
> spin_lock_irq(&(xa)->xa_lock);
> entry = __xa_erase(xa, index);
> spin_unlock_irq(&(xa)->xa_lock);
>
> return entry;
>}
># 684 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_cmpxchg(struct xarray *xa, unsigned long index,
>   void *old, void *entry, gfp_t gfp)
>{
> void *curr;
>
> spin_lock(&(xa)->xa_lock);
> curr = __xa_cmpxchg(xa, index, old, entry, gfp);
> spin_unlock(&(xa)->xa_lock);
>
> return curr;
>}
># 711 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_cmpxchg_bh(struct xarray *xa, unsigned long index,
>   void *old, void *entry, gfp_t gfp)
>{
> void *curr;
>
> spin_lock_bh(&(xa)->xa_lock);
> curr = __xa_cmpxchg(xa, index, old, entry, gfp);
> spin_unlock_bh(&(xa)->xa_lock);
>
> return curr;
>}
># 738 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_cmpxchg_irq(struct xarray *xa, unsigned long index,
>   void *old, void *entry, gfp_t gfp)
>{
> void *curr;
>
> spin_lock_irq(&(xa)->xa_lock);
> curr = __xa_cmpxchg(xa, index, old, entry, gfp);
> spin_unlock_irq(&(xa)->xa_lock);
>
> return curr;
>}
># 767 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) xa_insert(struct xarray *xa,
>  unsigned long index, void *entry, gfp_t gfp)
>{
> int err;
>
> spin_lock(&(xa)->xa_lock);
> err = __xa_insert(xa, index, entry, gfp);
> spin_unlock(&(xa)->xa_lock);
>
> return err;
>}
># 796 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) xa_insert_bh(struct xarray *xa,
>  unsigned long index, void *entry, gfp_t gfp)
>{
> int err;
>
> spin_lock_bh(&(xa)->xa_lock);
> err = __xa_insert(xa, index, entry, gfp);
> spin_unlock_bh(&(xa)->xa_lock);
>
> return err;
>}
># 825 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) xa_insert_irq(struct xarray *xa,
>  unsigned long index, void *entry, gfp_t gfp)
>{
> int err;
>
> spin_lock_irq(&(xa)->xa_lock);
> err = __xa_insert(xa, index, entry, gfp);
> spin_unlock_irq(&(xa)->xa_lock);
>
> return err;
>}
># 854 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) int xa_alloc(struct xarray *xa, u32 *id,
>  void *entry, struct xa_limit limit, gfp_t gfp)
>{
> int err;
>
> spin_lock(&(xa)->xa_lock);
> err = __xa_alloc(xa, id, entry, limit, gfp);
> spin_unlock(&(xa)->xa_lock);
>
> return err;
>}
># 883 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) xa_alloc_bh(struct xarray *xa, u32 *id,
>  void *entry, struct xa_limit limit, gfp_t gfp)
>{
> int err;
>
> spin_lock_bh(&(xa)->xa_lock);
> err = __xa_alloc(xa, id, entry, limit, gfp);
> spin_unlock_bh(&(xa)->xa_lock);
>
> return err;
>}
># 912 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) xa_alloc_irq(struct xarray *xa, u32 *id,
>  void *entry, struct xa_limit limit, gfp_t gfp)
>{
> int err;
>
> spin_lock_irq(&(xa)->xa_lock);
> err = __xa_alloc(xa, id, entry, limit, gfp);
> spin_unlock_irq(&(xa)->xa_lock);
>
> return err;
>}
># 945 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int xa_alloc_cyclic(struct xarray *xa, u32 *id, void *entry,
>  struct xa_limit limit, u32 *next, gfp_t gfp)
>{
> int err;
>
> spin_lock(&(xa)->xa_lock);
> err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
> spin_unlock(&(xa)->xa_lock);
>
> return err;
>}
># 978 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int xa_alloc_cyclic_bh(struct xarray *xa, u32 *id, void *entry,
>  struct xa_limit limit, u32 *next, gfp_t gfp)
>{
> int err;
>
> spin_lock_bh(&(xa)->xa_lock);
> err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
> spin_unlock_bh(&(xa)->xa_lock);
>
> return err;
>}
># 1011 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int xa_alloc_cyclic_irq(struct xarray *xa, u32 *id, void *entry,
>  struct xa_limit limit, u32 *next, gfp_t gfp)
>{
> int err;
>
> spin_lock_irq(&(xa)->xa_lock);
> err = __xa_alloc_cyclic(xa, id, entry, limit, next, gfp);
> spin_unlock_irq(&(xa)->xa_lock);
>
> return err;
>}
># 1041 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__))
>int xa_reserve(struct xarray *xa, unsigned long index, gfp_t gfp)
>{
> return xa_err(xa_cmpxchg(xa, index, ((void *)0), xa_mk_internal(257), gfp));
>}
># 1059 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__))
>int xa_reserve_bh(struct xarray *xa, unsigned long index, gfp_t gfp)
>{
> return xa_err(xa_cmpxchg_bh(xa, index, ((void *)0), xa_mk_internal(257), gfp));
>}
># 1077 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__))
>int xa_reserve_irq(struct xarray *xa, unsigned long index, gfp_t gfp)
>{
> return xa_err(xa_cmpxchg_irq(xa, index, ((void *)0), xa_mk_internal(257), gfp));
>}
># 1092 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xa_release(struct xarray *xa, unsigned long index)
>{
> xa_cmpxchg(xa, index, xa_mk_internal(257), ((void *)0), 0);
>}
># 1124 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>struct xa_node {
> unsigned char shift;
> unsigned char offset;
> unsigned char count;
> unsigned char nr_values;
> struct xa_node *parent;
> struct xarray *array;
> union {
>  struct list_head private_list;
>  struct callback_head callback_head;
> };
> void *slots[(1UL << (0 ? 4 : 6))];
> union {
>  unsigned long tags[3][((((1UL << (0 ? 4 : 6))) + (64) - 1) / (64))];
>  unsigned long marks[3][((((1UL << (0 ? 4 : 6))) + (64) - 1) / (64))];
> };
>};
>
>void xa_dump(const struct xarray *);
>void xa_dump_node(const struct xa_node *);
># 1164 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_head(const struct xarray *xa)
>{
> return ({ typeof(*(xa->xa_head)) *________p1 = (typeof(*(xa->xa_head)) *)({ do { extern void __compiletime_assert_204(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((xa->xa_head)) == sizeof(char) || sizeof((xa->xa_head)) == sizeof(short) || sizeof((xa->xa_head)) == sizeof(int) || sizeof((xa->xa_head)) == sizeof(long)) || sizeof((xa->xa_head)) == sizeof(long long))) __compiletime_assert_204(); } while (0); (*(const volatile typeof( _Generic(((xa->xa_head)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((xa->xa_head)))) *)&((xa->xa_head))); }); do { } while (0 && (!((lockdep_is_held(&xa->xa_lock)) || rcu_read_lock_held()))); ; ((typeof(*(xa->xa_head)) *)(________p1)); })
>                                    ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_head_locked(const struct xarray *xa)
>{
> return ({ do { } while (0 && (!((lockdep_is_held(&xa->xa_lock))))); ; ((typeof(*(xa->xa_head)) *)((xa->xa_head))); })
>                                    ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_entry(const struct xarray *xa,
>    const struct xa_node *node, unsigned int offset)
>{
> do { } while (0);
> return ({ typeof(*(node->slots[offset])) *________p1 = (typeof(*(node->slots[offset])) *)({ do { extern void __compiletime_assert_205(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((node->slots[offset])) == sizeof(char) || sizeof((node->slots[offset])) == sizeof(short) || sizeof((node->slots[offset])) == sizeof(int) || sizeof((node->slots[offset])) == sizeof(long)) || sizeof((node->slots[offset])) == sizeof(long long))) __compiletime_assert_205(); } while (0); (*(const volatile typeof( _Generic(((node->slots[offset])), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((node->slots[offset])))) *)&((node->slots[offset]))); }); do { } while (0 && (!((lockdep_is_held(&xa->xa_lock)) || rcu_read_lock_held()))); ; ((typeof(*(node->slots[offset])) *)(________p1)); })
>                                    ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_entry_locked(const struct xarray *xa,
>    const struct xa_node *node, unsigned int offset)
>{
> do { } while (0);
> return ({ do { } while (0 && (!((lockdep_is_held(&xa->xa_lock))))); ; ((typeof(*(node->slots[offset])) *)((node->slots[offset]))); })
>                                    ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct xa_node *xa_parent(const struct xarray *xa,
>     const struct xa_node *node)
>{
> return ({ typeof(*(node->parent)) *________p1 = (typeof(*(node->parent)) *)({ do { extern void __compiletime_assert_206(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((node->parent)) == sizeof(char) || sizeof((node->parent)) == sizeof(short) || sizeof((node->parent)) == sizeof(int) || sizeof((node->parent)) == sizeof(long)) || sizeof((node->parent)) == sizeof(long long))) __compiletime_assert_206(); } while (0); (*(const volatile typeof( _Generic(((node->parent)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((node->parent)))) *)&((node->parent))); }); do { } while (0 && (!((lockdep_is_held(&xa->xa_lock)) || rcu_read_lock_held()))); ; ((typeof(*(node->parent)) *)(________p1)); })
>                                    ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct xa_node *xa_parent_locked(const struct xarray *xa,
>     const struct xa_node *node)
>{
> return ({ do { } while (0 && (!((lockdep_is_held(&xa->xa_lock))))); ; ((typeof(*(node->parent)) *)((node->parent))); })
>                                    ;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_mk_node(const struct xa_node *node)
>{
> return (void *)((unsigned long)node | 2);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct xa_node *xa_to_node(const void *entry)
>{
> return (struct xa_node *)((unsigned long)entry - 2);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_node(const void *entry)
>{
> return xa_is_internal(entry) && (unsigned long)entry > 4096;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xa_mk_sibling(unsigned int offset)
>{
> return xa_mk_internal(offset);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long xa_to_sibling(const void *entry)
>{
> return xa_to_internal(entry);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_sibling(const void *entry)
>{
> return 1 && xa_is_internal(entry) &&
>  (entry < xa_mk_sibling((1UL << (0 ? 4 : 6)) - 1));
>}
># 1261 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_retry(const void *entry)
>{
> return __builtin_expect(!!(entry == xa_mk_internal(256)), 0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xa_is_advanced(const void *entry)
>{
> return xa_is_internal(entry) && (entry <= xa_mk_internal(256));
>}
># 1289 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>typedef void (*xa_update_node_t)(struct xa_node *node);
>
>void xa_delete_node(struct xa_node *, xa_update_node_t);
># 1310 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>struct xa_state {
> struct xarray *xa;
> unsigned long xa_index;
> unsigned char xa_shift;
> unsigned char xa_sibs;
> unsigned char xa_offset;
> unsigned char xa_pad;
> struct xa_node *xa_node;
> struct xa_node *xa_alloc;
> xa_update_node_t xa_update;
>};
># 1389 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int xas_error(const struct xa_state *xas)
>{
> return xa_err(xas->xa_node);
>}
># 1403 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xas_set_err(struct xa_state *xas, long err)
>{
> xas->xa_node = ((struct xa_node *)(((unsigned long)err << 2) | 2UL));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_invalid(const struct xa_state *xas)
>{
> return (unsigned long)xas->xa_node & 3;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_valid(const struct xa_state *xas)
>{
> return !xas_invalid(xas);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_is_node(const struct xa_state *xas)
>{
> return xas_valid(xas) && xas->xa_node;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_not_node(struct xa_node *node)
>{
> return ((unsigned long)node & 3) || !node;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_frozen(struct xa_node *node)
>{
> return (unsigned long)node & 2;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_top(struct xa_node *node)
>{
> return node <= ((struct xa_node *)3UL);
>}
># 1469 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xas_reset(struct xa_state *xas)
>{
> xas->xa_node = ((struct xa_node *)3UL);
>}
># 1486 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool xas_retry(struct xa_state *xas, const void *entry)
>{
> if (xa_is_zero(entry))
>  return true;
> if (!xa_is_retry(entry))
>  return false;
> xas_reset(xas);
> return true;
>}
>
>void *xas_load(struct xa_state *);
>void *xas_store(struct xa_state *, void *entry);
>void *xas_find(struct xa_state *, unsigned long max);
>void *xas_find_conflict(struct xa_state *);
>
>bool xas_get_mark(const struct xa_state *, xa_mark_t);
>void xas_set_mark(const struct xa_state *, xa_mark_t);
>void xas_clear_mark(const struct xa_state *, xa_mark_t);
>void *xas_find_marked(struct xa_state *, unsigned long max, xa_mark_t);
>void xas_init_marks(const struct xa_state *);
>
>bool xas_nomem(struct xa_state *, gfp_t);
>void xas_pause(struct xa_state *);
>
>void xas_create_range(struct xa_state *);
>
>
>int xa_get_order(struct xarray *, unsigned long index);
>void xas_split(struct xa_state *, void *entry, unsigned int order);
>void xas_split_alloc(struct xa_state *, void *entry, unsigned int order, gfp_t);
># 1548 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xas_reload(struct xa_state *xas)
>{
> struct xa_node *node = xas->xa_node;
> void *entry;
> char offset;
>
> if (!node)
>  return xa_head(xas->xa);
> if (1) {
>  offset = (xas->xa_index >> node->shift) & ((1UL << (0 ? 4 : 6)) - 1);
>  entry = xa_entry(xas->xa, node, offset);
>  if (!xa_is_sibling(entry))
>   return entry;
>  offset = xa_to_sibling(entry);
> } else {
>  offset = xas->xa_offset;
> }
> return xa_entry(xas->xa, node, offset);
>}
># 1577 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xas_set(struct xa_state *xas, unsigned long index)
>{
> xas->xa_index = index;
> xas->xa_node = ((struct xa_node *)3UL);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xas_set_order(struct xa_state *xas, unsigned long index,
>     unsigned int order)
>{
>
> xas->xa_index = order < 64 ? (index >> order) << order : 0;
> xas->xa_shift = order - (order % (0 ? 4 : 6));
> xas->xa_sibs = (1 << (order % (0 ? 4 : 6))) - 1;
> xas->xa_node = ((struct xa_node *)3UL);
>
>
>
>
>}
># 1611 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void xas_set_update(struct xa_state *xas, xa_update_node_t update)
>{
> xas->xa_update = update;
>}
># 1627 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xas_next_entry(struct xa_state *xas, unsigned long max)
>{
> struct xa_node *node = xas->xa_node;
> void *entry;
>
> if (__builtin_expect(!!(xas_not_node(node) || node->shift || xas->xa_offset != (xas->xa_index & ((1UL << (0 ? 4 : 6)) - 1))), 0)
>                                                     )
>  return xas_find(xas, max);
>
> do {
>  if (__builtin_expect(!!(xas->xa_index >= max), 0))
>   return xas_find(xas, max);
>  if (__builtin_expect(!!(xas->xa_offset == ((1UL << (0 ? 4 : 6)) - 1)), 0))
>   return xas_find(xas, max);
>  entry = xa_entry(xas->xa, node, xas->xa_offset + 1);
>  if (__builtin_expect(!!(xa_is_internal(entry)), 0))
>   return xas_find(xas, max);
>  xas->xa_offset++;
>  xas->xa_index++;
> } while (!entry);
>
> return entry;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int xas_find_chunk(struct xa_state *xas, bool advance,
>  xa_mark_t mark)
>{
> unsigned long *addr = xas->xa_node->marks[( unsigned)mark];
> unsigned int offset = xas->xa_offset;
>
> if (advance)
>  offset++;
> if ((1UL << (0 ? 4 : 6)) == 64) {
>  if (offset < (1UL << (0 ? 4 : 6))) {
>   unsigned long data = *addr & (~0UL << offset);
>   if (data)
>    return __ffs(data);
>  }
>  return (1UL << (0 ? 4 : 6));
> }
>
> return find_next_bit(addr, (1UL << (0 ? 4 : 6)), offset);
>}
># 1684 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xas_next_marked(struct xa_state *xas, unsigned long max,
>        xa_mark_t mark)
>{
> struct xa_node *node = xas->xa_node;
> void *entry;
> unsigned int offset;
>
> if (__builtin_expect(!!(xas_not_node(node) || node->shift), 0))
>  return xas_find_marked(xas, max, mark);
> offset = xas_find_chunk(xas, true, mark);
> xas->xa_offset = offset;
> xas->xa_index = (xas->xa_index & ~((1UL << (0 ? 4 : 6)) - 1)) + offset;
> if (xas->xa_index > max)
>  return ((void *)0);
> if (offset == (1UL << (0 ? 4 : 6)))
>  return xas_find_marked(xas, max, mark);
> entry = xa_entry(xas->xa, node, offset);
> if (!entry)
>  return xas_find_marked(xas, max, mark);
> return entry;
>}
>
>
>
>
>
>enum {
> XA_CHECK_SCHED = 4096,
>};
># 1764 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>void *__xas_next(struct xa_state *);
>void *__xas_prev(struct xa_state *);
># 1783 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xas_prev(struct xa_state *xas)
>{
> struct xa_node *node = xas->xa_node;
>
> if (__builtin_expect(!!(xas_not_node(node) || node->shift || xas->xa_offset == 0), 0)
>                        )
>  return __xas_prev(xas);
>
> xas->xa_index--;
> xas->xa_offset--;
> return xa_entry(xas->xa, node, xas->xa_offset);
>}
># 1812 "/usr/src/linux-5.14.21-150500.53/include/linux/xarray.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *xas_next(struct xa_state *xas)
>{
> struct xa_node *node = xas->xa_node;
>
> if (__builtin_expect(!!(xas_not_node(node) || node->shift || xas->xa_offset == ((1UL << (0 ? 4 : 6)) - 1)), 0)
>                                    )
>  return __xas_next(xas);
>
> xas->xa_index++;
> xas->xa_offset++;
> return xa_entry(xas->xa, node, xas->xa_offset);
>}
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h" 2
>
>
>
>
>
>
>struct radix_tree_preload {
> local_lock_t lock;
> unsigned nr;
>
> struct xa_node *nodes;
>};
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_radix_tree_preloads; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct radix_tree_preload) radix_tree_preloads;
># 53 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool radix_tree_is_internal_node(void *ptr)
>{
> return ((unsigned long)ptr & 3UL) ==
>    2UL;
>}
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool radix_tree_empty(const struct xarray *root)
>{
> return root->xa_head == ((void *)0);
>}
># 104 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>struct radix_tree_iter {
> unsigned long index;
> unsigned long next_index;
> unsigned long tags;
> struct xa_node *node;
>};
># 175 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *radix_tree_deref_slot(void **slot)
>{
> return ({ typeof(*(*slot)) *________p1 = (typeof(*(*slot)) *)({ do { extern void __compiletime_assert_207(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((*slot)) == sizeof(char) || sizeof((*slot)) == sizeof(short) || sizeof((*slot)) == sizeof(int) || sizeof((*slot)) == sizeof(long)) || sizeof((*slot)) == sizeof(long long))) __compiletime_assert_207(); } while (0); (*(const volatile typeof( _Generic(((*slot)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((*slot)))) *)&((*slot))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(*slot)) *)(________p1)); });
>}
># 189 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *radix_tree_deref_slot_protected(void **slot,
>       spinlock_t *treelock)
>{
> return ({ do { } while (0 && (!((lockdep_is_held(treelock))))); ; ((typeof(*(*slot)) *)((*slot))); });
>}
># 202 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int radix_tree_deref_retry(void *arg)
>{
> return __builtin_expect(!!(radix_tree_is_internal_node(arg)), 0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int radix_tree_exception(void *arg)
>{
> return __builtin_expect(!!((unsigned long)arg & 3UL), 0);
>}
>
>int radix_tree_insert(struct xarray *, unsigned long index,
>   void *);
>void *__radix_tree_lookup(const struct xarray *, unsigned long index,
>     struct xa_node **nodep, void ***slotp);
>void *radix_tree_lookup(const struct xarray *, unsigned long);
>void **radix_tree_lookup_slot(const struct xarray *,
>     unsigned long index);
>void __radix_tree_replace(struct xarray *, struct xa_node *,
>     void **slot, void *entry);
>void radix_tree_iter_replace(struct xarray *,
>  const struct radix_tree_iter *, void **slot, void *entry);
>void radix_tree_replace_slot(struct xarray *,
>        void **slot, void *entry);
>void radix_tree_iter_delete(struct xarray *,
>   struct radix_tree_iter *iter, void **slot);
>void *radix_tree_delete_item(struct xarray *, unsigned long, void *);
>void *radix_tree_delete(struct xarray *, unsigned long);
>unsigned int radix_tree_gang_lookup(const struct xarray *,
>   void **results, unsigned long first_index,
>   unsigned int max_items);
>int radix_tree_preload(gfp_t gfp_mask);
>int radix_tree_maybe_preload(gfp_t gfp_mask);
>void radix_tree_init(void);
>void *radix_tree_tag_set(struct xarray *,
>   unsigned long index, unsigned int tag);
>void *radix_tree_tag_clear(struct xarray *,
>   unsigned long index, unsigned int tag);
>int radix_tree_tag_get(const struct xarray *,
>   unsigned long index, unsigned int tag);
>void radix_tree_iter_tag_clear(struct xarray *,
>  const struct radix_tree_iter *iter, unsigned int tag);
>unsigned int radix_tree_gang_lookup_tag(const struct xarray *,
>  void **results, unsigned long first_index,
>  unsigned int max_items, unsigned int tag);
>unsigned int radix_tree_gang_lookup_tag_slot(const struct xarray *,
>  void ***results, unsigned long first_index,
>  unsigned int max_items, unsigned int tag);
>int radix_tree_tagged(const struct xarray *, unsigned int tag);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void radix_tree_preload_end(void)
>{
> do { do { ({ local_lock_t * __dummy; typeof(({ do { const void *__vpp_verify = (typeof((&radix_tree_preloads.lock) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long tcp_ptr__; asm volatile("add " "%%""gs"":" "%" "1" ", %0" : "=r" (tcp_ptr__) : "m" (this_cpu_off), "0" (&radix_tree_preloads.lock)); (typeof(*(&radix_tree_preloads.lock)) *)tcp_ptr__; }); })) __dummy2; (void)(&__dummy == &__dummy2); 1; }); } while (0); do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0); } while (0);
>}
>
>void **idr_get_free(struct xarray *root,
>         struct radix_tree_iter *iter, gfp_t gfp,
>         unsigned long max);
>
>enum {
> RADIX_TREE_ITER_TAG_MASK = 0x0f,
> RADIX_TREE_ITER_TAGGED = 0x10,
> RADIX_TREE_ITER_CONTIG = 0x20,
>};
># 278 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void **
>radix_tree_iter_init(struct radix_tree_iter *iter, unsigned long start)
>{
># 289 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
> iter->index = 0;
> iter->next_index = start;
> return ((void *)0);
>}
># 307 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>void **radix_tree_next_chunk(const struct xarray *,
>        struct radix_tree_iter *iter, unsigned flags);
># 320 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void **
>radix_tree_iter_lookup(const struct xarray *root,
>   struct radix_tree_iter *iter, unsigned long index)
>{
> radix_tree_iter_init(iter, index);
> return radix_tree_next_chunk(root, iter, RADIX_TREE_ITER_CONTIG);
>}
># 337 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__))
>void **radix_tree_iter_retry(struct radix_tree_iter *iter)
>{
> iter->next_index = iter->index;
> iter->tags = 0;
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>__radix_tree_iter_add(struct radix_tree_iter *iter, unsigned long slots)
>{
> return iter->index + slots;
>}
># 361 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>void **__attribute__((__warn_unused_result__)) radix_tree_iter_resume(void **slot,
>     struct radix_tree_iter *iter);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) long
>radix_tree_chunk_size(struct radix_tree_iter *iter)
>{
> return iter->next_index - iter->index;
>}
># 395 "/usr/src/linux-5.14.21-150500.53/include/linux/radix-tree.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void **radix_tree_next_slot(void **slot,
>    struct radix_tree_iter *iter, unsigned flags)
>{
> if (flags & RADIX_TREE_ITER_TAGGED) {
>  iter->tags >>= 1;
>  if (__builtin_expect(!!(!iter->tags), 0))
>   return ((void *)0);
>  if (__builtin_expect(!!(iter->tags & 1ul), 1)) {
>   iter->index = __radix_tree_iter_add(iter, 1);
>   slot++;
>   goto found;
>  }
>  if (!(flags & RADIX_TREE_ITER_CONTIG)) {
>   unsigned offset = __ffs(iter->tags);
>
>   iter->tags >>= offset++;
>   iter->index = __radix_tree_iter_add(iter, offset);
>   slot += offset;
>   goto found;
>  }
> } else {
>  long count = radix_tree_chunk_size(iter);
>
>  while (--count > 0) {
>   slot++;
>   iter->index = __radix_tree_iter_add(iter, 1);
>
>   if (__builtin_expect(!!(*slot), 1))
>    goto found;
>   if (flags & RADIX_TREE_ITER_CONTIG) {
>
>    iter->next_index = 0;
>    break;
>   }
>  }
> }
> return ((void *)0);
>
> found:
> return slot;
>}
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/capability.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/capability.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/capability.h" 1
># 39 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/capability.h"
>typedef struct __user_cap_header_struct {
> __u32 version;
> int pid;
>} *cap_user_header_t;
>
>typedef struct __user_cap_data_struct {
>        __u32 effective;
>        __u32 permitted;
>        __u32 inheritable;
>} *cap_user_data_t;
># 72 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/capability.h"
>struct vfs_cap_data {
> __le32 magic_etc;
> struct {
>  __le32 permitted;
>  __le32 inheritable;
> } data[2];
>};
>
>
>
>
>struct vfs_ns_cap_data {
> __le32 magic_etc;
> struct {
>  __le32 permitted;
>  __le32 inheritable;
> } data[2];
> __le32 rootid;
>};
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/capability.h" 2
>
>
>
>
>
>extern int file_caps_enabled;
>
>typedef struct kernel_cap_struct {
> __u32 cap[2];
>} kernel_cap_t;
>
>
>struct cpu_vfs_cap_data {
> __u32 magic_etc;
> kernel_cap_t permitted;
> kernel_cap_t inheritable;
> kuid_t rootid;
>};
>
>
>
>
>
>struct file;
>struct inode;
>struct dentry;
>struct task_struct;
>struct user_namespace;
>
>extern const kernel_cap_t __cap_empty_set;
>extern const kernel_cap_t __cap_init_eff_set;
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/capability.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_combine(const kernel_cap_t a,
>           const kernel_cap_t b)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] | b.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_intersect(const kernel_cap_t a,
>      const kernel_cap_t b)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] & b.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_drop(const kernel_cap_t a,
>        const kernel_cap_t drop)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = a.cap[__capi] &~ drop.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_invert(const kernel_cap_t c)
>{
> kernel_cap_t dest;
> do { unsigned __capi; for (__capi = 0; __capi < 2; ++__capi) { dest.cap[__capi] = ~ c.cap[__capi]; } } while (0);
> return dest;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cap_isclear(const kernel_cap_t a)
>{
> unsigned __capi;
> for (__capi = 0; __capi < 2; ++__capi) {
>  if (a.cap[__capi] != 0)
>   return false;
> }
> return true;
>}
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/capability.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cap_issubset(const kernel_cap_t a, const kernel_cap_t set)
>{
> kernel_cap_t dest;
> dest = cap_drop(a, set);
> return cap_isclear(dest);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_drop_fs_set(const kernel_cap_t a)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1U << ((0) & 31)) | (1U << ((27) & 31)) | (1U << ((1) & 31)) | (1U << ((2) & 31)) | (1U << ((3) & 31)) | (1U << ((4) & 31))) | (1U << ((9) & 31)), ((1U << ((32) & 31))) } });
> return cap_drop(a, __cap_fs_set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_raise_fs_set(const kernel_cap_t a,
>         const kernel_cap_t permitted)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1U << ((0) & 31)) | (1U << ((27) & 31)) | (1U << ((1) & 31)) | (1U << ((2) & 31)) | (1U << ((3) & 31)) | (1U << ((4) & 31))) | (1U << ((9) & 31)), ((1U << ((32) & 31))) } });
> return cap_combine(a,
>      cap_intersect(permitted, __cap_fs_set));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_drop_nfsd_set(const kernel_cap_t a)
>{
> const kernel_cap_t __cap_fs_set = ((kernel_cap_t){{ ((1U << ((0) & 31)) | (1U << ((27) & 31)) | (1U << ((1) & 31)) | (1U << ((2) & 31)) | (1U << ((3) & 31)) | (1U << ((4) & 31))) | (1U << ((24) & 31)), ((1U << ((32) & 31))) } });
> return cap_drop(a, __cap_fs_set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kernel_cap_t cap_raise_nfsd_set(const kernel_cap_t a,
>           const kernel_cap_t permitted)
>{
> const kernel_cap_t __cap_nfsd_set = ((kernel_cap_t){{ ((1U << ((0) & 31)) | (1U << ((27) & 31)) | (1U << ((1) & 31)) | (1U << ((2) & 31)) | (1U << ((3) & 31)) | (1U << ((4) & 31))) | (1U << ((24) & 31)), ((1U << ((32) & 31))) } });
> return cap_combine(a,
>      cap_intersect(permitted, __cap_nfsd_set));
>}
>
>
>extern bool has_capability(struct task_struct *t, int cap);
>extern bool has_ns_capability(struct task_struct *t,
>         struct user_namespace *ns, int cap);
>extern bool has_capability_noaudit(struct task_struct *t, int cap);
>extern bool has_ns_capability_noaudit(struct task_struct *t,
>          struct user_namespace *ns, int cap);
>extern bool capable(int cap);
>extern bool ns_capable(struct user_namespace *ns, int cap);
>extern bool ns_capable_noaudit(struct user_namespace *ns, int cap);
>extern bool ns_capable_setid(struct user_namespace *ns, int cap);
># 250 "/usr/src/linux-5.14.21-150500.53/include/linux/capability.h"
>bool privileged_wrt_inode_uidgid(struct user_namespace *ns,
>     struct user_namespace *mnt_userns,
>     const struct inode *inode);
>bool capable_wrt_inode_uidgid(struct user_namespace *mnt_userns,
>         const struct inode *inode, int cap);
>extern bool file_ns_capable(const struct file *file, struct user_namespace *ns, int cap);
>extern bool ptracer_capable(struct task_struct *tsk, struct user_namespace *ns);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool perfmon_capable(void)
>{
> return capable(38) || capable(21);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bpf_capable(void)
>{
> return capable(39) || capable(21);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool checkpoint_restore_ns_capable(struct user_namespace *ns)
>{
> return ns_capable(ns, 40) ||
>  ns_capable(ns, 21);
>}
>
>
>int get_vfs_caps_from_disk(struct user_namespace *mnt_userns,
>      const struct dentry *dentry,
>      struct cpu_vfs_cap_data *cpu_caps);
>
>int cap_convert_nscap(struct user_namespace *mnt_userns, struct dentry *dentry,
>        const void **ivalue, size_t size);
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fcntl.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fcntl.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/fcntl.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/fcntl.h" 1
># 156 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/fcntl.h"
>struct f_owner_ex {
> int type;
> __kernel_pid_t pid;
>};
># 196 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/fcntl.h"
>struct flock {
> short l_type;
> short l_whence;
> __kernel_off_t l_start;
> __kernel_off_t l_len;
> __kernel_pid_t l_pid;
>
>};
>
>
>
>
>
>
>
>struct flock64 {
> short l_type;
> short l_whence;
> __kernel_loff_t l_start;
> __kernel_loff_t l_len;
> __kernel_pid_t l_pid;
>
>};
># 1 "./arch/x86/include/generated/uapi/asm/fcntl.h" 2
># 6 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fcntl.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/openat2.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/openat2.h"
>struct open_how {
> __u64 flags;
> __u64 mode;
> __u64 resolve;
>};
># 7 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fcntl.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/fcntl.h" 2
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/migrate_mode.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/migrate_mode.h"
>enum migrate_mode {
> MIGRATE_ASYNC,
> MIGRATE_SYNC_LIGHT,
> MIGRATE_SYNC,
> MIGRATE_SYNC_NO_COPY,
>};
>
>enum migrate_reason {
> MR_COMPACTION,
> MR_MEMORY_FAILURE,
> MR_MEMORY_HOTPLUG,
> MR_SYSCALL,
> MR_MEMPOLICY_MBIND,
> MR_NUMA_MISPLACED,
> MR_CONTIG_RANGE,
> MR_LONGTERM_PIN,
> MR_DEMOTION,
> MR_TYPES
>};
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-rwsem.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rcuwait.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>struct task_struct;
>
>
>extern int print_fatal_signals;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void copy_siginfo(kernel_siginfo_t *to,
>    const kernel_siginfo_t *from)
>{
> memcpy(to, from, sizeof(*to));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_siginfo(kernel_siginfo_t *info)
>{
> memset(info, 0, sizeof(*info));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void copy_siginfo_to_external(siginfo_t *to,
>         const kernel_siginfo_t *from)
>{
> memcpy(to, from, sizeof(*from));
> memset(((char *)to) + sizeof(struct kernel_siginfo), 0,
>  (sizeof(struct siginfo) - sizeof(struct kernel_siginfo)));
>}
>
>int copy_siginfo_to_user(siginfo_t *to, const kernel_siginfo_t *from);
>int copy_siginfo_from_user(kernel_siginfo_t *to, const siginfo_t *from);
>
>enum siginfo_layout {
> SIL_KILL,
> SIL_TIMER,
> SIL_POLL,
> SIL_FAULT,
> SIL_FAULT_TRAPNO,
> SIL_FAULT_MCEERR,
> SIL_FAULT_BNDERR,
> SIL_FAULT_PKUERR,
> SIL_PERF_EVENT,
> SIL_CHLD,
> SIL_RT,
> SIL_SYS,
>};
>
>enum siginfo_layout siginfo_layout(unsigned sig, int si_code);
># 64 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigaddset(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 64) == 1)
>  set->sig[0] |= 1UL << sig;
> else
>  set->sig[sig / 64] |= 1UL << (sig % 64);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigdelset(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 64) == 1)
>  set->sig[0] &= ~(1UL << sig);
> else
>  set->sig[sig / 64] &= ~(1UL << (sig % 64));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sigismember(sigset_t *set, int _sig)
>{
> unsigned long sig = _sig - 1;
> if ((64 / 64) == 1)
>  return 1 & (set->sig[0] >> sig);
> else
>  return 1 & (set->sig[sig / 64] >> (sig % 64));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sigisemptyset(sigset_t *set)
>{
> switch ((64 / 64)) {
> case 4:
>  return (set->sig[3] | set->sig[2] |
>   set->sig[1] | set->sig[0]) == 0;
> case 2:
>  return (set->sig[1] | set->sig[0]) == 0;
> case 1:
>  return set->sig[0] == 0;
> default:
>  do { extern void __compiletime_assert_208(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_208(); } while (0);
>  return 0;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sigequalsets(const sigset_t *set1, const sigset_t *set2)
>{
> switch ((64 / 64)) {
> case 4:
>  return (set1->sig[3] == set2->sig[3]) &&
>   (set1->sig[2] == set2->sig[2]) &&
>   (set1->sig[1] == set2->sig[1]) &&
>   (set1->sig[0] == set2->sig[0]);
> case 2:
>  return (set1->sig[1] == set2->sig[1]) &&
>   (set1->sig[0] == set2->sig[0]);
> case 1:
>  return set1->sig[0] == set2->sig[0];
> }
> return 0;
>}
># 157 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigorsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) | (b3)); r->sig[2] = ((a2) | (b2)); __attribute__((__fallthrough__)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) | (b1)); __attribute__((__fallthrough__)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) | (b0)); break; default: do { extern void __compiletime_assert_209(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_209(); } while (0); } }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigandsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & (b3)); r->sig[2] = ((a2) & (b2)); __attribute__((__fallthrough__)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & (b1)); __attribute__((__fallthrough__)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & (b0)); break; default: do { extern void __compiletime_assert_210(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_210(); } while (0); } }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigandnsets(sigset_t *r, const sigset_t *a, const sigset_t *b) { unsigned long a0, a1, a2, a3, b0, b1, b2, b3; switch ((64 / 64)) { case 4: a3 = a->sig[3]; a2 = a->sig[2]; b3 = b->sig[3]; b2 = b->sig[2]; r->sig[3] = ((a3) & ~(b3)); r->sig[2] = ((a2) & ~(b2)); __attribute__((__fallthrough__)); case 2: a1 = a->sig[1]; b1 = b->sig[1]; r->sig[1] = ((a1) & ~(b1)); __attribute__((__fallthrough__)); case 1: a0 = a->sig[0]; b0 = b->sig[0]; r->sig[0] = ((a0) & ~(b0)); break; default: do { extern void __compiletime_assert_211(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_211(); } while (0); } }
># 187 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void signotset(sigset_t *set) { switch ((64 / 64)) { case 4: set->sig[3] = (~(set->sig[3])); set->sig[2] = (~(set->sig[2])); __attribute__((__fallthrough__)); case 2: set->sig[1] = (~(set->sig[1])); __attribute__((__fallthrough__)); case 1: set->sig[0] = (~(set->sig[0])); break; default: do { extern void __compiletime_assert_212(void) __attribute__((__error__("BUILD_BUG failed"))); if (!(!(1))) __compiletime_assert_212(); } while (0); } }
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigemptyset(sigset_t *set)
>{
> switch ((64 / 64)) {
> default:
>  memset(set, 0, sizeof(sigset_t));
>  break;
> case 2: set->sig[1] = 0;
>  __attribute__((__fallthrough__));
> case 1: set->sig[0] = 0;
>  break;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigfillset(sigset_t *set)
>{
> switch ((64 / 64)) {
> default:
>  memset(set, -1, sizeof(sigset_t));
>  break;
> case 2: set->sig[1] = -1;
>  __attribute__((__fallthrough__));
> case 1: set->sig[0] = -1;
>  break;
> }
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigaddsetmask(sigset_t *set, unsigned long mask)
>{
> set->sig[0] |= mask;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sigdelsetmask(sigset_t *set, unsigned long mask)
>{
> set->sig[0] &= ~mask;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sigtestsetmask(sigset_t *set, unsigned long mask)
>{
> return (set->sig[0] & mask) != 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void siginitset(sigset_t *set, unsigned long mask)
>{
> set->sig[0] = mask;
> switch ((64 / 64)) {
> default:
>  memset(&set->sig[1], 0, sizeof(long)*((64 / 64)-1));
>  break;
> case 2: set->sig[1] = 0;
>  break;
> case 1: ;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void siginitsetinv(sigset_t *set, unsigned long mask)
>{
> set->sig[0] = ~mask;
> switch ((64 / 64)) {
> default:
>  memset(&set->sig[1], -1, sizeof(long)*((64 / 64)-1));
>  break;
> case 2: set->sig[1] = -1;
>  break;
> case 1: ;
> }
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_sigpending(struct sigpending *sig)
>{
> sigemptyset(&sig->signal);
> INIT_LIST_HEAD(&sig->list);
>}
>
>extern void flush_sigqueue(struct sigpending *queue);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int valid_signal(unsigned long sig)
>{
> return sig <= 64 ? 1 : 0;
>}
>
>struct timespec;
>struct pt_regs;
>enum pid_type;
>
>extern int next_signal(struct sigpending *pending, sigset_t *mask);
>extern int do_send_sig_info(int sig, struct kernel_siginfo *info,
>    struct task_struct *p, enum pid_type type);
>extern int group_send_sig_info(int sig, struct kernel_siginfo *info,
>          struct task_struct *p, enum pid_type type);
>extern int __group_send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
>extern int sigprocmask(int, sigset_t *, sigset_t *);
>extern void set_current_blocked(sigset_t *);
>extern void __set_current_blocked(const sigset_t *);
>extern int show_unhandled_signals;
>
>extern bool get_signal(struct ksignal *ksig);
>extern void signal_setup_done(int failed, struct ksignal *ksig, int stepping);
>extern void exit_signals(struct task_struct *tsk);
>extern void kernel_sigaction(int, __sighandler_t);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void allow_signal(int sig)
>{
>
>
>
>
>
> kernel_sigaction(sig, (( __sighandler_t)2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void allow_kernel_signal(int sig)
>{
>
>
>
>
>
> kernel_sigaction(sig, (( __sighandler_t)3));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void disallow_signal(int sig)
>{
> kernel_sigaction(sig, (( __sighandler_t)1));
>}
>
>extern struct kmem_cache *sighand_cachep;
>
>extern bool unhandled_signal(struct task_struct *tsk, int sig);
># 454 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>void signals_init(void);
>
>int restore_altstack(const stack_t *);
>int __save_altstack(stack_t *, unsigned long);
># 468 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>bool sigaltstack_size_valid(size_t ss_size);
>
>
>
>
>
>struct seq_file;
>extern void render_sigset_t(struct seq_file *, const char *, sigset_t *);
># 484 "/usr/src/linux-5.14.21-150500.53/include/linux/signal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *arch_untagged_si_addr(void *addr,
>       unsigned long sig,
>       unsigned long si_code)
>{
> return addr;
>}
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/jobctl.h" 1
>
>
>
>
>
>
>struct task_struct;
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/jobctl.h"
>extern bool task_set_jobctl_pending(struct task_struct *task, unsigned long mask);
>extern void task_clear_jobctl_trapping(struct task_struct *task);
>extern void task_clear_jobctl_pending(struct task_struct *task, unsigned long mask);
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fault-inject-usercopy.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/fault-inject-usercopy.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool should_fail_usercopy(void) { return false; }
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/smap.h" 1
># 41 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/smap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void clac(void)
>{
>
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 9*32+20)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" ".byte 0x0f,0x01,0xca" "\n" "665""1" ":\n" ".popsection\n" : : : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void stac(void)
>{
>
> asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 9*32+20)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" ".byte 0x0f,0x01,0xcb" "\n" "665""1" ":\n" ".popsection\n" : : : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long smap_save(void)
>{
> unsigned long flags;
>
> asm volatile ("# smap_save\n\t"
>        "# ALT: oldnstr\n" "661:\n\t" "" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 9*32+20)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "pushf; pop %0; " ".byte 0x0f,0x01,0xca" "\n\t" "\n" "665""1" ":\n" ".popsection\n"
>
>        : "=rm" (flags) : : "memory", "cc");
>
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void smap_restore(unsigned long flags)
>{
> asm volatile ("# smap_restore\n\t"
>        "# ALT: oldnstr\n" "661:\n\t" "" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 9*32+20)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "push %0; popf\n\t" "\n" "665""1" ":\n" ".popsection\n"
>
>        : : "g" (flags) : "memory", "cc");
>}
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/extable.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/extable.h"
>struct exception_table_entry {
> int insn, fixup, type;
>};
>struct pt_regs;
># 38 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/extable.h"
>extern int fixup_exception(struct pt_regs *regs, int trapnr,
>      unsigned long error_code, unsigned long fault_addr);
>extern int fixup_bug(struct pt_regs *regs, int trapnr);
>extern int ex_get_fixup_type(unsigned long ip);
>extern void early_fixup_exception(struct pt_regs *regs, int trapnr);
>
>
>extern void ex_handler_msr_mce(struct pt_regs *regs, bool wrmsr);
>
>
>
>
>
>bool ex_handler_bpf(const struct exception_table_entry *x, struct pt_regs *regs);
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h" 2
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __chk_range_not_ok(unsigned long addr, unsigned long size, unsigned long limit)
>{
>
>
>
>
>
>
>
> if (__builtin_constant_p(size))
>  return __builtin_expect(!!(addr > limit - size), 0);
>
>
> addr += size;
> if (__builtin_expect(!!(addr < size), 0))
>  return true;
> return __builtin_expect(!!(addr > limit), 0);
>}
># 75 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
>extern int __get_user_1(void);
>extern int __get_user_2(void);
>extern int __get_user_4(void);
>extern int __get_user_8(void);
>extern int __get_user_nocheck_1(void);
>extern int __get_user_nocheck_2(void);
>extern int __get_user_nocheck_4(void);
>extern int __get_user_nocheck_8(void);
>extern int __get_user_bad(void);
># 196 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
>extern void __put_user_bad(void);
>
>
>
>
>
>extern void __put_user_1(void);
>extern void __put_user_2(void);
>extern void __put_user_4(void);
>extern void __put_user_8(void);
>extern void __put_user_nocheck_1(void);
>extern void __put_user_nocheck_2(void);
>extern void __put_user_nocheck_4(void);
>extern void __put_user_nocheck_8(void);
># 514 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
>struct __large_struct { unsigned long buf[100]; };
># 529 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
>extern unsigned long
>copy_from_user_nmi(void *to, const void *from, unsigned long n);
>extern __attribute__((__warn_unused_result__)) long
>strncpy_from_user(char *dst, const char *src, long count);
>
>extern __attribute__((__warn_unused_result__)) long strnlen_user(const char *str, long n);
>
>unsigned long __attribute__((__warn_unused_result__)) clear_user(void *mem, unsigned long len);
>unsigned long __attribute__((__warn_unused_result__)) __clear_user(void *mem, unsigned long len);
>
>
>unsigned long __attribute__((__warn_unused_result__))
>copy_mc_to_kernel(void *to, const void *from, unsigned len);
>
>
>unsigned long __attribute__((__warn_unused_result__))
>copy_mc_to_user(void *to, const void *from, unsigned len);
># 562 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess_64.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess_64.h"
>__attribute__((__warn_unused_result__)) unsigned long
>copy_user_enhanced_fast_string(void *to, const void *from, unsigned len);
>__attribute__((__warn_unused_result__)) unsigned long
>copy_user_generic_string(void *to, const void *from, unsigned len);
>__attribute__((__warn_unused_result__)) unsigned long
>copy_user_generic_unrolled(void *to, const void *from, unsigned len);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>copy_user_generic(void *to, const void *from, unsigned len)
>{
> unsigned ret;
>
>
>
>
>
>
> asm __inline volatile ("# ALT: oldinstr2\n" "661:\n\t" "call %P[old]" "\n662:\n" "# ALT: padding2\n" ".skip -((" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")) > 0) * " "(" "((" "665""1""f-""664""1""f" ") ^ (((" "665""1""f-""664""1""f" ") ^ (" "665""2""f-""664""2""f" ")) & -(-((" "665""1""f-""664""1""f" ") < (" "665""2""f-""664""2""f" ")))))" " - (" "662b-661b" ")), 0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 3*32+16)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" " .long 661b - .\n" " .long " "664""2""f - .\n" " .word " "( 9*32+ 9)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""2""f-""664""2""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "call %P[new1]" "\n" "665""1" ":\n" "# ALT: replacement " "2" "\n" "664""2"":\n\t" "call %P[new2]" "\n" "665""2" ":\n" ".popsection\n" : "=a" (ret), "=D" (to), "=S" (from), "=d" (len), "+r" (current_stack_pointer) : [old] "i" (copy_user_generic_unrolled), [new1] "i" (copy_user_generic_string), [new2] "i" (copy_user_enhanced_fast_string), "1" (to), "2" (from), "3" (len) : "memory", "rcx", "r8", "r9", "r10", "r11")
>
>
>
>
>
>
>
>                                                ;
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>raw_copy_from_user(void *dst, const void *src, unsigned long size)
>{
> return copy_user_generic(dst, ( void *)src, size);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>raw_copy_to_user(void *dst, const void *src, unsigned long size)
>{
> return copy_user_generic(( void *)dst, src, size);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>unsigned long raw_copy_in_user(void *dst, const void *src, unsigned long size)
>{
> return copy_user_generic(( void *)dst,
>     ( void *)src, size);
>}
>
>extern long __copy_user_nocache(void *dst, const void *src,
>    unsigned size, int zerorest);
>
>extern long __copy_user_flushcache(void *dst, const void *src, unsigned size);
>extern void memcpy_page_flushcache(char *to, struct page *page, size_t offset,
>      size_t len);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>__copy_from_user_inatomic_nocache(void *dst, const void *src,
>      unsigned size)
>{
> kasan_check_write(dst, size);
> return __copy_user_nocache(dst, src, size, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>__copy_from_user_flushcache(void *dst, const void *src, unsigned size)
>{
> kasan_check_write(dst, size);
> return __copy_user_flushcache(dst, src, size);
>}
># 563 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h" 2
># 571 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
>static __attribute__((__warn_unused_result__)) inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool user_access_begin(const void *ptr, size_t len)
>{
> if (__builtin_expect(!!(!({ ; __builtin_expect(!!(!({ (void)0; __chk_range_not_ok((unsigned long )(ptr), len, task_size_max()); })), 1); })), 0))
>  return 0;
> ({ stac(); asm __inline volatile ("# ALT: oldnstr\n" "661:\n\t" "" "\n662:\n" "# ALT: padding\n" ".skip -(((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")) > 0) * " "((" "665""1""f-""664""1""f" ")-(" "662b-661b" ")),0x90\n" "663" ":\n" ".pushsection .altinstructions,\"a\"\n" " .long 661b - .\n" " .long " "664""1""f - .\n" " .word " "( 3*32+18)" "\n" " .byte " "663""b-661b" "\n" " .byte " "665""1""f-""664""1""f" "\n" ".popsection\n" ".pushsection .altinstr_replacement, \"ax\"\n" "# ALT: replacement " "1" "\n" "664""1"":\n\t" "lfence" "\n" "665""1" ":\n" ".popsection\n" : : : "memory"); });
> return 1;
>}
># 605 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/uaccess.h"
>extern void __try_cmpxchg_user_wrong_size(void);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h" 2
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>typedef struct {
>
>} mm_segment_t;
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) mm_segment_t force_uaccess_begin(void)
>{
> return (mm_segment_t) { };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void force_uaccess_end(mm_segment_t oldfs)
>{
>}
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>__copy_from_user_inatomic(void *to, const void *from, unsigned long n)
>{
> instrument_copy_from_user(to, from, n);
> check_object_size(to, n, false);
> return raw_copy_from_user(to, from, n);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>__copy_from_user(void *to, const void *from, unsigned long n)
>{
> might_fault();
> if (should_fail_usercopy())
>  return n;
> instrument_copy_from_user(to, from, n);
> check_object_size(to, n, false);
> return raw_copy_from_user(to, from, n);
>}
># 130 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>__copy_to_user_inatomic(void *to, const void *from, unsigned long n)
>{
> if (should_fail_usercopy())
>  return n;
> instrument_copy_to_user(to, from, n);
> check_object_size(from, n, true);
> return raw_copy_to_user(to, from, n);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) unsigned long
>__copy_to_user(void *to, const void *from, unsigned long n)
>{
> might_fault();
> if (should_fail_usercopy())
>  return n;
> instrument_copy_to_user(to, from, n);
> check_object_size(from, n, true);
> return raw_copy_to_user(to, from, n);
>}
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>extern __attribute__((__warn_unused_result__)) unsigned long
>_copy_from_user(void *, const void *, unsigned long);
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>extern __attribute__((__warn_unused_result__)) unsigned long
>_copy_to_user(void *, const void *, unsigned long);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __attribute__((__warn_unused_result__))
>copy_from_user(void *to, const void *from, unsigned long n)
>{
> if (__builtin_expect(!!(check_copy_size(to, n, false)), 1))
>  n = _copy_from_user(to, from, n);
> return n;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __attribute__((__warn_unused_result__))
>copy_to_user(void *to, const void *from, unsigned long n)
>{
> if (__builtin_expect(!!(check_copy_size(from, n, true)), 1))
>  n = _copy_to_user(to, from, n);
> return n;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long __attribute__((__warn_unused_result__))
>copy_in_user(void *to, const void *from, unsigned long n)
>{
> might_fault();
> if (({ ; __builtin_expect(!!(!({ (void)0; __chk_range_not_ok((unsigned long )(to), n, task_size_max()); })), 1); }) && ({ ; __builtin_expect(!!(!({ (void)0; __chk_range_not_ok((unsigned long )(from), n, task_size_max()); })), 1); }))
>  n = raw_copy_in_user(to, from, n);
> return n;
>}
># 227 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void pagefault_disabled_inc(void)
>{
> get_current()->pagefault_disabled++;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void pagefault_disabled_dec(void)
>{
> get_current()->pagefault_disabled--;
>}
># 244 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pagefault_disable(void)
>{
> pagefault_disabled_inc();
>
>
>
>
> __asm__ __volatile__("": : :"memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pagefault_enable(void)
>{
>
>
>
>
> __asm__ __volatile__("": : :"memory");
> pagefault_disabled_dec();
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pagefault_disabled(void)
>{
> return get_current()->pagefault_disabled != 0;
>}
># 299 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t probe_subpage_writeable(char *uaddr, size_t size)
>{
> return 0;
>}
># 317 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>extern __attribute__((__warn_unused_result__)) int check_zeroed_user(const void *from, size_t size);
># 366 "/usr/src/linux-5.14.21-150500.53/include/linux/uaccess.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__)) int
>copy_struct_from_user(void *dst, size_t ksize, const void *src,
>        size_t usize)
>{
> size_t size = __builtin_choose_expr(((!!(sizeof((typeof(ksize) *)1 == (typeof(usize) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(ksize) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(usize) * 0l)) : (int *)8))))), ((ksize) < (usize) ? (ksize) : (usize)), ({ typeof(ksize) __UNIQUE_ID___x213 = (ksize); typeof(usize) __UNIQUE_ID___y214 = (usize); ((__UNIQUE_ID___x213) < (__UNIQUE_ID___y214) ? (__UNIQUE_ID___x213) : (__UNIQUE_ID___y214)); }));
> size_t rest = __builtin_choose_expr(((!!(sizeof((typeof(ksize) *)1 == (typeof(usize) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(ksize) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(usize) * 0l)) : (int *)8))))), ((ksize) > (usize) ? (ksize) : (usize)), ({ typeof(ksize) __UNIQUE_ID___x215 = (ksize); typeof(usize) __UNIQUE_ID___y216 = (usize); ((__UNIQUE_ID___x215) > (__UNIQUE_ID___y216) ? (__UNIQUE_ID___x215) : (__UNIQUE_ID___y216)); })) - size;
>
>
> if (usize < ksize) {
>  memset(dst + size, 0, rest);
> } else if (usize > ksize) {
>  int ret = check_zeroed_user(src + size, rest);
>  if (ret <= 0)
>   return ret ?: -7;
> }
>
> if (copy_from_user(dst, src, size))
>  return -14;
> return 0;
>}
>
>bool copy_from_kernel_nofault_allowed(const void *unsafe_src, size_t size);
>
>long copy_from_kernel_nofault(void *dst, const void *src, size_t size);
>long __attribute__((no_instrument_function)) copy_to_kernel_nofault(void *dst, const void *src, size_t size);
>
>long copy_from_user_nofault(void *dst, const void *src, size_t size);
>long __attribute__((no_instrument_function)) copy_to_user_nofault(void *dst, const void *src,
>  size_t size);
>
>long strncpy_from_kernel_nofault(char *dst, const void *unsafe_addr,
>  long count);
>
>long strncpy_from_user_nofault(char *dst, const void *unsafe_addr,
>  long count);
>long strnlen_user_nofault(const void *unsafe_addr, long count);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task.h" 2
>
>struct task_struct;
>struct rusage;
>union thread_union;
>struct css_set;
>
>
>
>
>struct kernel_clone_args {
> u64 flags;
> int *pidfd;
> int *child_tid;
> int *parent_tid;
> int exit_signal;
> unsigned long stack;
> unsigned long stack_size;
> unsigned long tls;
> pid_t *set_tid;
>
> size_t set_tid_size;
> int cgroup;
> int io_thread;
> struct cgroup *cgrp;
> struct css_set *cset;
>};
>
>
>
>
>
>
>
>extern rwlock_t tasklist_lock;
>extern spinlock_t mmlist_lock;
>
>extern union thread_union init_thread_union;
>extern struct task_struct init_task;
>
>extern int lockdep_tasklist_lock_is_held(void);
>
>extern void schedule_tail(struct task_struct *prev);
>extern void init_idle(struct task_struct *idle, int cpu);
>
>extern int sched_fork(unsigned long clone_flags, struct task_struct *p);
>extern void sched_cgroup_fork(struct task_struct *p, struct kernel_clone_args *kargs);
>extern void sched_post_fork(struct task_struct *p);
>extern void sched_dead(struct task_struct *p);
>
>void __attribute__((__noreturn__)) do_task_dead(void);
>
>extern void proc_caches_init(void);
>
>extern void fork_init(void);
>
>extern void release_task(struct task_struct * p);
>
>extern int copy_thread(unsigned long, unsigned long, unsigned long,
>         struct task_struct *, unsigned long);
>
>extern void flush_thread(void);
>
>
>extern void exit_thread(struct task_struct *tsk);
>
>
>
>
>
>extern void do_group_exit(int);
>
>extern void exit_files(struct task_struct *);
>extern void exit_itimers(struct task_struct *);
>
>extern pid_t kernel_clone(struct kernel_clone_args *kargs);
>struct task_struct *create_io_thread(int (*fn)(void *), void *arg, int node);
>struct task_struct *fork_idle(int);
>struct mm_struct *copy_init_mm(void);
>extern pid_t kernel_thread(int (*fn)(void *), void *arg, unsigned long flags);
>extern long kernel_wait4(pid_t, int *, int, struct rusage *);
>int kernel_wait(pid_t pid, int *stat);
>
>extern void free_task(struct task_struct *tsk);
>
>
>
>extern void sched_exec(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct task_struct *get_task_struct(struct task_struct *t)
>{
> refcount_inc(&t->usage);
> return t;
>}
>
>extern void __put_task_struct(struct task_struct *t);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_task_struct(struct task_struct *t)
>{
> if (refcount_dec_and_test(&t->usage))
>  __put_task_struct(t);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_task_struct_many(struct task_struct *t, int nr)
>{
> if (refcount_sub_and_test(nr, &t->usage))
>  __put_task_struct(t);
>}
>
>void put_task_struct_rcu_user(struct task_struct *task);
>
>
>extern int arch_task_struct_size __attribute__((__section__(".data..read_mostly")));
># 146 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct vm_struct *task_stack_vm_area(const struct task_struct *t)
>{
> return t->stack_vm_area;
>}
># 167 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_lock(struct task_struct *p)
>{
> spin_lock(&p->alloc_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void task_unlock(struct task_struct *p)
>{
> spin_unlock(&p->alloc_lock);
>}
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h" 1
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sysctl.h" 1
># 35 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sysctl.h"
>struct __sysctl_args {
> int *name;
> int nlen;
> void *oldval;
> size_t *oldlenp;
> void *newval;
> size_t newlen;
> unsigned long __unused[4];
>};
>
>
>
>
>
>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
>{
> CTL_BUS_ISA=1
>};
>
>
>enum
>{
> INOTIFY_MAX_USER_INSTANCES=1,
> INOTIFY_MAX_USER_WATCHES=2,
> INOTIFY_MAX_QUEUED_EVENTS=3
>};
>
>
>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,
> KERN_PANIC_PRINT=78,
>};
>
>
>
>
>enum
>{
> VM_UNUSED1=1,
> VM_UNUSED2=2,
> VM_UNUSED3=3,
> VM_UNUSED4=4,
> VM_OVERCOMMIT_MEMORY=5,
> VM_UNUSED5=6,
> VM_UNUSED7=7,
> VM_UNUSED8=8,
> VM_UNUSED9=9,
> VM_PAGE_CLUSTER=10,
> VM_DIRTY_BACKGROUND=11,
> VM_DIRTY_RATIO=12,
> VM_DIRTY_WB_CS=13,
> VM_DIRTY_EXPIRE_CS=14,
> VM_NR_PDFLUSH_THREADS=15,
> VM_OVERCOMMIT_RATIO=16,
> VM_PAGEBUF=17,
> VM_HUGETLB_PAGES=18,
> VM_SWAPPINESS=19,
> VM_LOWMEM_RESERVE_RATIO=20,
> VM_MIN_FREE_KBYTES=21,
> VM_MAX_MAP_COUNT=22,
> VM_LAPTOP_MODE=23,
> VM_BLOCK_DUMP=24,
> VM_HUGETLB_GROUP=25,
> VM_VFS_CACHE_PRESSURE=26,
> VM_LEGACY_VA_LAYOUT=27,
> VM_SWAP_TOKEN_TIMEOUT=28,
> VM_DROP_PAGECACHE=29,
> VM_PERCPU_PAGELIST_FRACTION=30,
> VM_ZONE_RECLAIM_MODE=31,
> VM_MIN_UNMAPPED=32,
> VM_PANIC_ON_OOM=33,
> VM_VDSO_ENABLED=34,
> VM_MIN_SLAB=35,
>};
>
>
>
>enum
>{
> NET_CORE=1,
> NET_ETHER=2,
> NET_802=3,
> NET_UNIX=4,
> NET_IPV4=5,
> NET_IPX=6,
> NET_ATALK=7,
> NET_NETROM=8,
> NET_AX25=9,
> NET_BRIDGE=10,
> NET_ROSE=11,
> NET_IPV6=12,
> NET_X25=13,
> NET_TR=14,
> NET_DECNET=15,
> NET_ECONET=16,
> NET_SCTP=17,
> NET_LLC=18,
> NET_NETFILTER=19,
> NET_DCCP=20,
> NET_IRDA=412,
>};
>
>
>enum
>{
> RANDOM_POOLSIZE=1,
> RANDOM_ENTROPY_COUNT=2,
> RANDOM_READ_THRESH=3,
> RANDOM_WRITE_THRESH=4,
> RANDOM_BOOT_ID=5,
> RANDOM_UUID=6
>};
>
>
>enum
>{
> PTY_MAX=1,
> PTY_NR=2
>};
>
>
>enum
>{
> BUS_ISA_MEM_BASE=1,
> BUS_ISA_PORT_BASE=2,
> BUS_ISA_PORT_SHIFT=3
>};
>
>
>enum
>{
> NET_CORE_WMEM_MAX=1,
> NET_CORE_RMEM_MAX=2,
> NET_CORE_WMEM_DEFAULT=3,
> NET_CORE_RMEM_DEFAULT=4,
>
> NET_CORE_MAX_BACKLOG=6,
> NET_CORE_FASTROUTE=7,
> NET_CORE_MSG_COST=8,
> NET_CORE_MSG_BURST=9,
> NET_CORE_OPTMEM_MAX=10,
> NET_CORE_HOT_LIST_LENGTH=11,
> NET_CORE_DIVERT_VERSION=12,
> NET_CORE_NO_CONG_THRESH=13,
> NET_CORE_NO_CONG=14,
> NET_CORE_LO_CONG=15,
> NET_CORE_MOD_CONG=16,
> NET_CORE_DEV_WEIGHT=17,
> NET_CORE_SOMAXCONN=18,
> NET_CORE_BUDGET=19,
> NET_CORE_AEVENT_ETIME=20,
> NET_CORE_AEVENT_RSEQTH=21,
> NET_CORE_WARNINGS=22,
>};
>
>
>
>
>
>
>
>enum
>{
> NET_UNIX_DESTROY_DELAY=1,
> NET_UNIX_DELETE_DELAY=2,
> NET_UNIX_MAX_DGRAM_QLEN=3,
>};
>
>
>enum
>{
> NET_NF_CONNTRACK_MAX=1,
> NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT=2,
> NET_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV=3,
> NET_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED=4,
> NET_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT=5,
> NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT=6,
> NET_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK=7,
> NET_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT=8,
> NET_NF_CONNTRACK_TCP_TIMEOUT_CLOSE=9,
> NET_NF_CONNTRACK_UDP_TIMEOUT=10,
> NET_NF_CONNTRACK_UDP_TIMEOUT_STREAM=11,
> NET_NF_CONNTRACK_ICMP_TIMEOUT=12,
> NET_NF_CONNTRACK_GENERIC_TIMEOUT=13,
> NET_NF_CONNTRACK_BUCKETS=14,
> NET_NF_CONNTRACK_LOG_INVALID=15,
> NET_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS=16,
> NET_NF_CONNTRACK_TCP_LOOSE=17,
> NET_NF_CONNTRACK_TCP_BE_LIBERAL=18,
> NET_NF_CONNTRACK_TCP_MAX_RETRANS=19,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED=20,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT=21,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED=22,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED=23,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT=24,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD=25,
> NET_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT=26,
> NET_NF_CONNTRACK_COUNT=27,
> NET_NF_CONNTRACK_ICMPV6_TIMEOUT=28,
> NET_NF_CONNTRACK_FRAG6_TIMEOUT=29,
> NET_NF_CONNTRACK_FRAG6_LOW_THRESH=30,
> NET_NF_CONNTRACK_FRAG6_HIGH_THRESH=31,
> NET_NF_CONNTRACK_CHECKSUM=32,
>};
>
>
>enum
>{
>
> NET_IPV4_FORWARD=8,
> NET_IPV4_DYNADDR=9,
>
> NET_IPV4_CONF=16,
> NET_IPV4_NEIGH=17,
> NET_IPV4_ROUTE=18,
> NET_IPV4_FIB_HASH=19,
> NET_IPV4_NETFILTER=20,
>
> NET_IPV4_TCP_TIMESTAMPS=33,
> NET_IPV4_TCP_WINDOW_SCALING=34,
> NET_IPV4_TCP_SACK=35,
> NET_IPV4_TCP_RETRANS_COLLAPSE=36,
> NET_IPV4_DEFAULT_TTL=37,
> NET_IPV4_AUTOCONFIG=38,
> NET_IPV4_NO_PMTU_DISC=39,
> NET_IPV4_TCP_SYN_RETRIES=40,
> NET_IPV4_IPFRAG_HIGH_THRESH=41,
> NET_IPV4_IPFRAG_LOW_THRESH=42,
> NET_IPV4_IPFRAG_TIME=43,
> NET_IPV4_TCP_MAX_KA_PROBES=44,
> NET_IPV4_TCP_KEEPALIVE_TIME=45,
> NET_IPV4_TCP_KEEPALIVE_PROBES=46,
> NET_IPV4_TCP_RETRIES1=47,
> NET_IPV4_TCP_RETRIES2=48,
> NET_IPV4_TCP_FIN_TIMEOUT=49,
> NET_IPV4_IP_MASQ_DEBUG=50,
> NET_TCP_SYNCOOKIES=51,
> NET_TCP_STDURG=52,
> NET_TCP_RFC1337=53,
> NET_TCP_SYN_TAILDROP=54,
> NET_TCP_MAX_SYN_BACKLOG=55,
> NET_IPV4_LOCAL_PORT_RANGE=56,
> NET_IPV4_ICMP_ECHO_IGNORE_ALL=57,
> NET_IPV4_ICMP_ECHO_IGNORE_BROADCASTS=58,
> NET_IPV4_ICMP_SOURCEQUENCH_RATE=59,
> NET_IPV4_ICMP_DESTUNREACH_RATE=60,
> NET_IPV4_ICMP_TIMEEXCEED_RATE=61,
> NET_IPV4_ICMP_PARAMPROB_RATE=62,
> NET_IPV4_ICMP_ECHOREPLY_RATE=63,
> NET_IPV4_ICMP_IGNORE_BOGUS_ERROR_RESPONSES=64,
> NET_IPV4_IGMP_MAX_MEMBERSHIPS=65,
> NET_TCP_TW_RECYCLE=66,
> NET_IPV4_ALWAYS_DEFRAG=67,
> NET_IPV4_TCP_KEEPALIVE_INTVL=68,
> NET_IPV4_INET_PEER_THRESHOLD=69,
> NET_IPV4_INET_PEER_MINTTL=70,
> NET_IPV4_INET_PEER_MAXTTL=71,
> NET_IPV4_INET_PEER_GC_MINTIME=72,
> NET_IPV4_INET_PEER_GC_MAXTIME=73,
> NET_TCP_ORPHAN_RETRIES=74,
> NET_TCP_ABORT_ON_OVERFLOW=75,
> NET_TCP_SYNACK_RETRIES=76,
> NET_TCP_MAX_ORPHANS=77,
> NET_TCP_MAX_TW_BUCKETS=78,
> NET_TCP_FACK=79,
> NET_TCP_REORDERING=80,
> NET_TCP_ECN=81,
> NET_TCP_DSACK=82,
> NET_TCP_MEM=83,
> NET_TCP_WMEM=84,
> NET_TCP_RMEM=85,
> NET_TCP_APP_WIN=86,
> NET_TCP_ADV_WIN_SCALE=87,
> NET_IPV4_NONLOCAL_BIND=88,
> NET_IPV4_ICMP_RATELIMIT=89,
> NET_IPV4_ICMP_RATEMASK=90,
> NET_TCP_TW_REUSE=91,
> NET_TCP_FRTO=92,
> NET_TCP_LOW_LATENCY=93,
> NET_IPV4_IPFRAG_SECRET_INTERVAL=94,
> NET_IPV4_IGMP_MAX_MSF=96,
> NET_TCP_NO_METRICS_SAVE=97,
> NET_TCP_DEFAULT_WIN_SCALE=105,
> NET_TCP_MODERATE_RCVBUF=106,
> NET_TCP_TSO_WIN_DIVISOR=107,
> NET_TCP_BIC_BETA=108,
> NET_IPV4_ICMP_ERRORS_USE_INBOUND_IFADDR=109,
> NET_TCP_CONG_CONTROL=110,
> NET_TCP_ABC=111,
> NET_IPV4_IPFRAG_MAX_DIST=112,
>  NET_TCP_MTU_PROBING=113,
> NET_TCP_BASE_MSS=114,
> NET_IPV4_TCP_WORKAROUND_SIGNED_WINDOWS=115,
> NET_TCP_DMA_COPYBREAK=116,
> NET_TCP_SLOW_START_AFTER_IDLE=117,
> NET_CIPSOV4_CACHE_ENABLE=118,
> NET_CIPSOV4_CACHE_BUCKET_SIZE=119,
> NET_CIPSOV4_RBM_OPTFMT=120,
> NET_CIPSOV4_RBM_STRICTVALID=121,
> NET_TCP_AVAIL_CONG_CONTROL=122,
> NET_TCP_ALLOWED_CONG_CONTROL=123,
> NET_TCP_MAX_SSTHRESH=124,
> NET_TCP_FRTO_RESPONSE=125,
>};
>
>enum {
> NET_IPV4_ROUTE_FLUSH=1,
> NET_IPV4_ROUTE_MIN_DELAY=2,
> NET_IPV4_ROUTE_MAX_DELAY=3,
> NET_IPV4_ROUTE_GC_THRESH=4,
> NET_IPV4_ROUTE_MAX_SIZE=5,
> NET_IPV4_ROUTE_GC_MIN_INTERVAL=6,
> NET_IPV4_ROUTE_GC_TIMEOUT=7,
> NET_IPV4_ROUTE_GC_INTERVAL=8,
> NET_IPV4_ROUTE_REDIRECT_LOAD=9,
> NET_IPV4_ROUTE_REDIRECT_NUMBER=10,
> NET_IPV4_ROUTE_REDIRECT_SILENCE=11,
> NET_IPV4_ROUTE_ERROR_COST=12,
> NET_IPV4_ROUTE_ERROR_BURST=13,
> NET_IPV4_ROUTE_GC_ELASTICITY=14,
> NET_IPV4_ROUTE_MTU_EXPIRES=15,
> NET_IPV4_ROUTE_MIN_PMTU=16,
> NET_IPV4_ROUTE_MIN_ADVMSS=17,
> NET_IPV4_ROUTE_SECRET_INTERVAL=18,
> NET_IPV4_ROUTE_GC_MIN_INTERVAL_MS=19,
>};
>
>enum
>{
> NET_PROTO_CONF_ALL=-2,
> NET_PROTO_CONF_DEFAULT=-3
>
>
>};
>
>enum
>{
> NET_IPV4_CONF_FORWARDING=1,
> NET_IPV4_CONF_MC_FORWARDING=2,
> NET_IPV4_CONF_PROXY_ARP=3,
> NET_IPV4_CONF_ACCEPT_REDIRECTS=4,
> NET_IPV4_CONF_SECURE_REDIRECTS=5,
> NET_IPV4_CONF_SEND_REDIRECTS=6,
> NET_IPV4_CONF_SHARED_MEDIA=7,
> NET_IPV4_CONF_RP_FILTER=8,
> NET_IPV4_CONF_ACCEPT_SOURCE_ROUTE=9,
> NET_IPV4_CONF_BOOTP_RELAY=10,
> NET_IPV4_CONF_LOG_MARTIANS=11,
> NET_IPV4_CONF_TAG=12,
> NET_IPV4_CONF_ARPFILTER=13,
> NET_IPV4_CONF_MEDIUM_ID=14,
> NET_IPV4_CONF_NOXFRM=15,
> NET_IPV4_CONF_NOPOLICY=16,
> NET_IPV4_CONF_FORCE_IGMP_VERSION=17,
> NET_IPV4_CONF_ARP_ANNOUNCE=18,
> NET_IPV4_CONF_ARP_IGNORE=19,
> NET_IPV4_CONF_PROMOTE_SECONDARIES=20,
> NET_IPV4_CONF_ARP_ACCEPT=21,
> NET_IPV4_CONF_ARP_NOTIFY=22,
>};
>
>
>enum
>{
> NET_IPV4_NF_CONNTRACK_MAX=1,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_SENT=2,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_SYN_RECV=3,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_ESTABLISHED=4,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_FIN_WAIT=5,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE_WAIT=6,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_LAST_ACK=7,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_TIME_WAIT=8,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_CLOSE=9,
> NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT=10,
> NET_IPV4_NF_CONNTRACK_UDP_TIMEOUT_STREAM=11,
> NET_IPV4_NF_CONNTRACK_ICMP_TIMEOUT=12,
> NET_IPV4_NF_CONNTRACK_GENERIC_TIMEOUT=13,
> NET_IPV4_NF_CONNTRACK_BUCKETS=14,
> NET_IPV4_NF_CONNTRACK_LOG_INVALID=15,
> NET_IPV4_NF_CONNTRACK_TCP_TIMEOUT_MAX_RETRANS=16,
> NET_IPV4_NF_CONNTRACK_TCP_LOOSE=17,
> NET_IPV4_NF_CONNTRACK_TCP_BE_LIBERAL=18,
> NET_IPV4_NF_CONNTRACK_TCP_MAX_RETRANS=19,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_CLOSED=20,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_WAIT=21,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_COOKIE_ECHOED=22,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_ESTABLISHED=23,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_SENT=24,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_RECD=25,
>  NET_IPV4_NF_CONNTRACK_SCTP_TIMEOUT_SHUTDOWN_ACK_SENT=26,
> NET_IPV4_NF_CONNTRACK_COUNT=27,
> NET_IPV4_NF_CONNTRACK_CHECKSUM=28,
>};
>
>
>enum {
> NET_IPV6_CONF=16,
> NET_IPV6_NEIGH=17,
> NET_IPV6_ROUTE=18,
> NET_IPV6_ICMP=19,
> NET_IPV6_BINDV6ONLY=20,
> NET_IPV6_IP6FRAG_HIGH_THRESH=21,
> NET_IPV6_IP6FRAG_LOW_THRESH=22,
> NET_IPV6_IP6FRAG_TIME=23,
> NET_IPV6_IP6FRAG_SECRET_INTERVAL=24,
> NET_IPV6_MLD_MAX_MSF=25,
>};
>
>enum {
> NET_IPV6_ROUTE_FLUSH=1,
> NET_IPV6_ROUTE_GC_THRESH=2,
> NET_IPV6_ROUTE_MAX_SIZE=3,
> NET_IPV6_ROUTE_GC_MIN_INTERVAL=4,
> NET_IPV6_ROUTE_GC_TIMEOUT=5,
> NET_IPV6_ROUTE_GC_INTERVAL=6,
> NET_IPV6_ROUTE_GC_ELASTICITY=7,
> NET_IPV6_ROUTE_MTU_EXPIRES=8,
> NET_IPV6_ROUTE_MIN_ADVMSS=9,
> NET_IPV6_ROUTE_GC_MIN_INTERVAL_MS=10
>};
>
>enum {
> NET_IPV6_FORWARDING=1,
> NET_IPV6_HOP_LIMIT=2,
> NET_IPV6_MTU=3,
> NET_IPV6_ACCEPT_RA=4,
> NET_IPV6_ACCEPT_REDIRECTS=5,
> NET_IPV6_AUTOCONF=6,
> NET_IPV6_DAD_TRANSMITS=7,
> NET_IPV6_RTR_SOLICITS=8,
> NET_IPV6_RTR_SOLICIT_INTERVAL=9,
> NET_IPV6_RTR_SOLICIT_DELAY=10,
> NET_IPV6_USE_TEMPADDR=11,
> NET_IPV6_TEMP_VALID_LFT=12,
> NET_IPV6_TEMP_PREFERED_LFT=13,
> NET_IPV6_REGEN_MAX_RETRY=14,
> NET_IPV6_MAX_DESYNC_FACTOR=15,
> NET_IPV6_MAX_ADDRESSES=16,
> NET_IPV6_FORCE_MLD_VERSION=17,
> NET_IPV6_ACCEPT_RA_DEFRTR=18,
> NET_IPV6_ACCEPT_RA_PINFO=19,
> NET_IPV6_ACCEPT_RA_RTR_PREF=20,
> NET_IPV6_RTR_PROBE_INTERVAL=21,
> NET_IPV6_ACCEPT_RA_RT_INFO_MAX_PLEN=22,
> NET_IPV6_PROXY_NDP=23,
> NET_IPV6_ACCEPT_SOURCE_ROUTE=25,
> NET_IPV6_ACCEPT_RA_FROM_LOCAL=26,
> NET_IPV6_ACCEPT_RA_RT_INFO_MIN_PLEN=27,
> NET_IPV6_RA_DEFRTR_METRIC=28,
> __NET_IPV6_MAX
>};
>
>
>enum {
> NET_IPV6_ICMP_RATELIMIT = 1,
> NET_IPV6_ICMP_ECHO_IGNORE_ALL = 2
>};
>
>
>enum {
> NET_NEIGH_MCAST_SOLICIT=1,
> NET_NEIGH_UCAST_SOLICIT=2,
> NET_NEIGH_APP_SOLICIT=3,
> NET_NEIGH_RETRANS_TIME=4,
> NET_NEIGH_REACHABLE_TIME=5,
> NET_NEIGH_DELAY_PROBE_TIME=6,
> NET_NEIGH_GC_STALE_TIME=7,
> NET_NEIGH_UNRES_QLEN=8,
> NET_NEIGH_PROXY_QLEN=9,
> NET_NEIGH_ANYCAST_DELAY=10,
> NET_NEIGH_PROXY_DELAY=11,
> NET_NEIGH_LOCKTIME=12,
> NET_NEIGH_GC_INTERVAL=13,
> NET_NEIGH_GC_THRESH1=14,
> NET_NEIGH_GC_THRESH2=15,
> NET_NEIGH_GC_THRESH3=16,
> NET_NEIGH_RETRANS_TIME_MS=17,
> NET_NEIGH_REACHABLE_TIME_MS=18,
>};
>
>
>enum {
> NET_DCCP_DEFAULT=1,
>};
>
>
>enum {
> NET_IPX_PPROP_BROADCASTING=1,
> NET_IPX_FORWARDING=2
>};
>
>
>enum {
> NET_LLC2=1,
> NET_LLC_STATION=2,
>};
>
>
>enum {
> NET_LLC2_TIMEOUT=1,
>};
>
>
>enum {
> NET_LLC_STATION_ACK_TIMEOUT=1,
>};
>
>
>enum {
> NET_LLC2_ACK_TIMEOUT=1,
> NET_LLC2_P_TIMEOUT=2,
> NET_LLC2_REJ_TIMEOUT=3,
> NET_LLC2_BUSY_TIMEOUT=4,
>};
>
>
>enum {
> NET_ATALK_AARP_EXPIRY_TIME=1,
> NET_ATALK_AARP_TICK_TIME=2,
> NET_ATALK_AARP_RETRANSMIT_LIMIT=3,
> NET_ATALK_AARP_RESOLVE_TIME=4
>};
>
>
>
>enum {
> NET_NETROM_DEFAULT_PATH_QUALITY=1,
> NET_NETROM_OBSOLESCENCE_COUNT_INITIALISER=2,
> NET_NETROM_NETWORK_TTL_INITIALISER=3,
> NET_NETROM_TRANSPORT_TIMEOUT=4,
> NET_NETROM_TRANSPORT_MAXIMUM_TRIES=5,
> NET_NETROM_TRANSPORT_ACKNOWLEDGE_DELAY=6,
> NET_NETROM_TRANSPORT_BUSY_DELAY=7,
> NET_NETROM_TRANSPORT_REQUESTED_WINDOW_SIZE=8,
> NET_NETROM_TRANSPORT_NO_ACTIVITY_TIMEOUT=9,
> NET_NETROM_ROUTING_CONTROL=10,
> NET_NETROM_LINK_FAILS_COUNT=11,
> NET_NETROM_RESET=12
>};
>
>
>enum {
> NET_AX25_IP_DEFAULT_MODE=1,
> NET_AX25_DEFAULT_MODE=2,
> NET_AX25_BACKOFF_TYPE=3,
> NET_AX25_CONNECT_MODE=4,
> NET_AX25_STANDARD_WINDOW=5,
> NET_AX25_EXTENDED_WINDOW=6,
> NET_AX25_T1_TIMEOUT=7,
> NET_AX25_T2_TIMEOUT=8,
> NET_AX25_T3_TIMEOUT=9,
> NET_AX25_IDLE_TIMEOUT=10,
> NET_AX25_N2=11,
> NET_AX25_PACLEN=12,
> NET_AX25_PROTOCOL=13,
> NET_AX25_DAMA_SLAVE_TIMEOUT=14
>};
>
>
>enum {
> NET_ROSE_RESTART_REQUEST_TIMEOUT=1,
> NET_ROSE_CALL_REQUEST_TIMEOUT=2,
> NET_ROSE_RESET_REQUEST_TIMEOUT=3,
> NET_ROSE_CLEAR_REQUEST_TIMEOUT=4,
> NET_ROSE_ACK_HOLD_BACK_TIMEOUT=5,
> NET_ROSE_ROUTING_CONTROL=6,
> NET_ROSE_LINK_FAIL_TIMEOUT=7,
> NET_ROSE_MAX_VCS=8,
> NET_ROSE_WINDOW_SIZE=9,
> NET_ROSE_NO_ACTIVITY_TIMEOUT=10
>};
>
>
>enum {
> NET_X25_RESTART_REQUEST_TIMEOUT=1,
> NET_X25_CALL_REQUEST_TIMEOUT=2,
> NET_X25_RESET_REQUEST_TIMEOUT=3,
> NET_X25_CLEAR_REQUEST_TIMEOUT=4,
> NET_X25_ACK_HOLD_BACK_TIMEOUT=5,
> NET_X25_FORWARD=6
>};
>
>
>enum
>{
> NET_TR_RIF_TIMEOUT=1
>};
>
>
>enum {
> NET_DECNET_NODE_TYPE = 1,
> NET_DECNET_NODE_ADDRESS = 2,
> NET_DECNET_NODE_NAME = 3,
> NET_DECNET_DEFAULT_DEVICE = 4,
> NET_DECNET_TIME_WAIT = 5,
> NET_DECNET_DN_COUNT = 6,
> NET_DECNET_DI_COUNT = 7,
> NET_DECNET_DR_COUNT = 8,
> NET_DECNET_DST_GC_INTERVAL = 9,
> NET_DECNET_CONF = 10,
> NET_DECNET_NO_FC_MAX_CWND = 11,
> NET_DECNET_MEM = 12,
> NET_DECNET_RMEM = 13,
> NET_DECNET_WMEM = 14,
> NET_DECNET_DEBUG_LEVEL = 255
>};
>
>
>enum {
> NET_DECNET_CONF_LOOPBACK = -2,
> NET_DECNET_CONF_DDCMP = -3,
> NET_DECNET_CONF_PPP = -4,
> NET_DECNET_CONF_X25 = -5,
> NET_DECNET_CONF_GRE = -6,
> NET_DECNET_CONF_ETHER = -7
>
>
>};
>
>
>enum {
> NET_DECNET_CONF_DEV_PRIORITY = 1,
> NET_DECNET_CONF_DEV_T1 = 2,
> NET_DECNET_CONF_DEV_T2 = 3,
> NET_DECNET_CONF_DEV_T3 = 4,
> NET_DECNET_CONF_DEV_FORWARDING = 5,
> NET_DECNET_CONF_DEV_BLKSIZE = 6,
> NET_DECNET_CONF_DEV_STATE = 7
>};
>
>
>enum {
> NET_SCTP_RTO_INITIAL = 1,
> NET_SCTP_RTO_MIN = 2,
> NET_SCTP_RTO_MAX = 3,
> NET_SCTP_RTO_ALPHA = 4,
> NET_SCTP_RTO_BETA = 5,
> NET_SCTP_VALID_COOKIE_LIFE = 6,
> NET_SCTP_ASSOCIATION_MAX_RETRANS = 7,
> NET_SCTP_PATH_MAX_RETRANS = 8,
> NET_SCTP_MAX_INIT_RETRANSMITS = 9,
> NET_SCTP_HB_INTERVAL = 10,
> NET_SCTP_PRESERVE_ENABLE = 11,
> NET_SCTP_MAX_BURST = 12,
> NET_SCTP_ADDIP_ENABLE = 13,
> NET_SCTP_PRSCTP_ENABLE = 14,
> NET_SCTP_SNDBUF_POLICY = 15,
> NET_SCTP_SACK_TIMEOUT = 16,
> NET_SCTP_RCVBUF_POLICY = 17,
>};
>
>
>enum {
> NET_BRIDGE_NF_CALL_ARPTABLES = 1,
> NET_BRIDGE_NF_CALL_IPTABLES = 2,
> NET_BRIDGE_NF_CALL_IP6TABLES = 3,
> NET_BRIDGE_NF_FILTER_VLAN_TAGGED = 4,
> NET_BRIDGE_NF_FILTER_PPPOE_TAGGED = 5,
>};
>
>
>
>enum
>{
> FS_NRINODE=1,
> FS_STATINODE=2,
> FS_MAXINODE=3,
> FS_NRDQUOT=4,
> FS_MAXDQUOT=5,
> FS_NRFILE=6,
> FS_MAXFILE=7,
> FS_DENTRY=8,
> FS_NRSUPER=9,
> FS_MAXSUPER=10,
> FS_OVERFLOWUID=11,
> FS_OVERFLOWGID=12,
> FS_LEASES=13,
> FS_DIR_NOTIFY=14,
> FS_LEASE_TIME=15,
> FS_DQSTATS=16,
> FS_XFS=17,
> FS_AIO_NR=18,
> FS_AIO_MAX_NR=19,
> FS_INOTIFY=20,
> FS_OCFS2=988,
>};
>
>
>enum {
> FS_DQ_LOOKUPS = 1,
> FS_DQ_DROPS = 2,
> FS_DQ_READS = 3,
> FS_DQ_WRITES = 4,
> FS_DQ_CACHE_HITS = 5,
> FS_DQ_ALLOCATED = 6,
> FS_DQ_FREE = 7,
> FS_DQ_SYNCS = 8,
> FS_DQ_WARNINGS = 9,
>};
>
>
>
>
>enum {
> DEV_CDROM=1,
> DEV_HWMON=2,
> DEV_PARPORT=3,
> DEV_RAID=4,
> DEV_MAC_HID=5,
> DEV_SCSI=6,
> DEV_IPMI=7,
>};
>
>
>enum {
> DEV_CDROM_INFO=1,
> DEV_CDROM_AUTOCLOSE=2,
> DEV_CDROM_AUTOEJECT=3,
> DEV_CDROM_DEBUG=4,
> DEV_CDROM_LOCK=5,
> DEV_CDROM_CHECK_MEDIA=6
>};
>
>
>enum {
> DEV_PARPORT_DEFAULT=-3
>};
>
>
>enum {
> DEV_RAID_SPEED_LIMIT_MIN=1,
> DEV_RAID_SPEED_LIMIT_MAX=2
>};
>
>
>enum {
> DEV_PARPORT_DEFAULT_TIMESLICE=1,
> DEV_PARPORT_DEFAULT_SPINTIME=2
>};
>
>
>enum {
> DEV_PARPORT_SPINTIME=1,
> DEV_PARPORT_BASE_ADDR=2,
> DEV_PARPORT_IRQ=3,
> DEV_PARPORT_DMA=4,
> DEV_PARPORT_MODES=5,
> DEV_PARPORT_DEVICES=6,
> DEV_PARPORT_AUTOPROBE=16
>};
>
>
>enum {
> DEV_PARPORT_DEVICES_ACTIVE=-3,
>};
>
>
>enum {
> DEV_PARPORT_DEVICE_TIMESLICE=1,
>};
>
>
>enum {
> DEV_MAC_HID_KEYBOARD_SENDS_LINUX_KEYCODES=1,
> DEV_MAC_HID_KEYBOARD_LOCK_KEYCODES=2,
> DEV_MAC_HID_MOUSE_BUTTON_EMULATION=3,
> DEV_MAC_HID_MOUSE_BUTTON2_KEYCODE=4,
> DEV_MAC_HID_MOUSE_BUTTON3_KEYCODE=5,
> DEV_MAC_HID_ADB_MOUSE_SENDS_KEYCODES=6
>};
>
>
>enum {
> DEV_SCSI_LOGGING_LEVEL=1,
>};
>
>
>enum {
> DEV_IPMI_POWEROFF_POWERCYCLE=1,
>};
>
>
>enum
>{
> ABI_DEFHANDLER_COFF=1,
> ABI_DEFHANDLER_ELF=2,
> ABI_DEFHANDLER_LCALL7=3,
> ABI_DEFHANDLER_LIBCSO=4,
> ABI_TRACE=5,
> ABI_FAKE_UTSNAME=6,
>};
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h" 2
>
>
>struct completion;
>struct ctl_table;
>struct nsproxy;
>struct ctl_table_root;
>struct ctl_table_header;
>struct ctl_dir;
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h"
>extern const int sysctl_vals[];
>
>typedef int proc_handler(struct ctl_table *ctl, int write, void *buffer,
>  size_t *lenp, loff_t *ppos);
>
>int proc_dostring(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_dointvec(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_douintvec(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_dointvec_minmax(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_douintvec_minmax(struct ctl_table *table, int write, void *buffer,
>  size_t *lenp, loff_t *ppos);
>int proc_dou8vec_minmax(struct ctl_table *table, int write, void *buffer,
>   size_t *lenp, loff_t *ppos);
>int proc_dointvec_jiffies(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_dointvec_userhz_jiffies(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>int proc_dointvec_ms_jiffies(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>int proc_doulongvec_minmax(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_doulongvec_ms_jiffies_minmax(struct ctl_table *table, int, void *,
>  size_t *, loff_t *);
>int proc_do_large_bitmap(struct ctl_table *, int, void *, size_t *, loff_t *);
>int proc_do_static_key(struct ctl_table *table, int write, void *buffer,
>  size_t *lenp, loff_t *ppos);
># 103 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h"
>struct ctl_table_poll {
> atomic_t event;
> wait_queue_head_t wait;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *proc_sys_poll_event(struct ctl_table_poll *poll)
>{
> return (void *)(unsigned long)atomic_read(&poll->event);
>}
># 121 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h"
>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;
>} __attribute__((__designated_init__));
>
>struct ctl_node {
> struct rb_node node;
> struct ctl_table_header *header;
>};
>
>
>
>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 hlist_head inodes;
>};
>
>struct ctl_dir {
>
> struct ctl_table_header header;
> struct rb_root root;
>};
>
>struct ctl_table_set {
> int (*is_seen)(struct ctl_table_set *);
> struct ctl_dir dir;
>};
>
>struct ctl_table_root {
> struct ctl_table_set default_set;
> struct ctl_table_set *(*lookup)(struct ctl_table_root *root);
> void (*set_ownership)(struct ctl_table_header *head,
>         struct ctl_table *table,
>         kuid_t *uid, kgid_t *gid);
> int (*permissions)(struct ctl_table_header *head, struct ctl_table *table);
>};
>
>
>struct ctl_path {
> const char *procname;
>};
>
>
>
>void proc_sys_poll_notify(struct ctl_table_poll *poll);
>
>extern void setup_sysctl_set(struct ctl_table_set *p,
> struct ctl_table_root *root,
> int (*is_seen)(struct ctl_table_set *));
>extern void retire_sysctl_set(struct ctl_table_set *set);
>
>struct ctl_table_header *__register_sysctl_table(
> struct ctl_table_set *set,
> const char *path, struct ctl_table *table);
>struct ctl_table_header *__register_sysctl_paths(
> struct ctl_table_set *set,
> const struct ctl_path *path, struct ctl_table *table);
>struct ctl_table_header *register_sysctl(const char *path, struct ctl_table *table);
>struct ctl_table_header *register_sysctl_table(struct ctl_table * table);
>struct ctl_table_header *register_sysctl_paths(const struct ctl_path *path,
>      struct ctl_table *table);
>
>void unregister_sysctl_table(struct ctl_table_header * table);
>
>extern int sysctl_init(void);
>extern void __register_sysctl_init(const char *path, struct ctl_table *table,
>     const char *table_name);
>
>void do_sysctl_args(void);
>
>extern int pwrsw_enabled;
>extern int unaligned_enabled;
>extern int unaligned_dump_stack;
>extern int no_unaligned_warning;
>
>extern struct ctl_table sysctl_mount_point[];
>extern struct ctl_table random_table[];
># 252 "/usr/src/linux-5.14.21-150500.53/include/linux/sysctl.h"
>int sysctl_max_threads(struct ctl_table *table, int write, void *buffer,
>  size_t *lenp, loff_t *ppos);
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/assoc_array.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/assoc_array.h"
>struct assoc_array {
> struct assoc_array_ptr *root;
> unsigned long nr_leaves_on_tree;
>};
>
>
>
>
>struct assoc_array_ops {
>
> unsigned long (*get_key_chunk)(const void *index_key, int level);
>
>
> unsigned long (*get_object_key_chunk)(const void *object, int level);
>
>
> bool (*compare_object)(const void *object, const void *index_key);
>
>
>
>
> int (*diff_objects)(const void *object, const void *index_key);
>
>
> void (*free_object)(void *object);
>};
>
>
>
>
>struct assoc_array_edit;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void assoc_array_init(struct assoc_array *array)
>{
> array->root = ((void *)0);
> array->nr_leaves_on_tree = 0;
>}
>
>extern int assoc_array_iterate(const struct assoc_array *array,
>          int (*iterator)(const void *object,
>            void *iterator_data),
>          void *iterator_data);
>extern void *assoc_array_find(const struct assoc_array *array,
>         const struct assoc_array_ops *ops,
>         const void *index_key);
>extern void assoc_array_destroy(struct assoc_array *array,
>    const struct assoc_array_ops *ops);
>extern struct assoc_array_edit *assoc_array_insert(struct assoc_array *array,
>         const struct assoc_array_ops *ops,
>         const void *index_key,
>         void *object);
>extern void assoc_array_insert_set_object(struct assoc_array_edit *edit,
>       void *object);
>extern struct assoc_array_edit *assoc_array_delete(struct assoc_array *array,
>         const struct assoc_array_ops *ops,
>         const void *index_key);
>extern struct assoc_array_edit *assoc_array_clear(struct assoc_array *array,
>        const struct assoc_array_ops *ops);
>extern void assoc_array_apply_edit(struct assoc_array_edit *edit);
>extern void assoc_array_cancel_edit(struct assoc_array_edit *edit);
>extern int assoc_array_gc(struct assoc_array *array,
>     const struct assoc_array_ops *ops,
>     bool (*iterator)(void *object, void *iterator_data),
>     void *iterator_data);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h" 2
>
>
>
>
>
>
>
>typedef int32_t key_serial_t;
>
>
>typedef uint32_t key_perm_t;
>
>struct key;
>struct net;
># 77 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>enum key_need_perm {
> KEY_NEED_UNSPECIFIED,
> KEY_NEED_VIEW,
> KEY_NEED_READ,
> KEY_NEED_WRITE,
> KEY_NEED_SEARCH,
> KEY_NEED_LINK,
> KEY_NEED_SETATTR,
> KEY_NEED_UNLINK,
> KEY_SYSADMIN_OVERRIDE,
> KEY_AUTHTOKEN_OVERRIDE,
> KEY_DEFER_PERM_CHECK,
>};
>
>struct seq_file;
>struct user_struct;
>struct signal_struct;
>struct cred;
>
>struct key_type;
>struct key_owner;
>struct key_tag;
>struct keyring_list;
>struct keyring_name;
>
>struct key_tag {
> struct callback_head rcu;
> refcount_t usage;
> bool removed;
>};
>
>struct keyring_index_key {
>
> unsigned long hash;
> union {
>  struct {
>
>   u16 desc_len;
>   char desc[sizeof(long) - 2];
>
>
>
>
>  };
>  unsigned long x;
> };
> struct key_type *type;
> struct key_tag *domain_tag;
> const char *description;
>};
>
>union key_payload {
> void *rcu_data0;
> void *data[4];
>};
># 147 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>typedef struct __key_reference_with_attributes *key_ref_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) key_ref_t make_key_ref(const struct key *key,
>         bool possession)
>{
> return (key_ref_t) ((unsigned long) key | possession);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct key *key_ref_to_ptr(const key_ref_t key_ref)
>{
> return (struct key *) ((unsigned long) key_ref & ~1UL);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_key_possessed(const key_ref_t key_ref)
>{
> return (unsigned long) key_ref & 1UL;
>}
>
>typedef int (*key_restrict_link_func_t)(struct key *dest_keyring,
>     const struct key_type *type,
>     const union key_payload *payload,
>     struct key *restriction_key);
>
>struct key_restriction {
> key_restrict_link_func_t check;
> struct key *key;
> struct key_type *keytype;
>};
>
>enum key_state {
> KEY_IS_UNINSTANTIATED,
> KEY_IS_POSITIVE,
>};
># 189 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>struct key {
> refcount_t usage;
> key_serial_t serial;
> union {
>  struct list_head graveyard_link;
>  struct rb_node serial_node;
> };
>
> struct watch_list *watchers;
>
> struct rw_semaphore sem;
> struct key_user *user;
> void *security;
> union {
>  time64_t expiry;
>  time64_t revoked_at;
> };
> time64_t last_used_at;
> kuid_t uid;
> kgid_t gid;
> key_perm_t perm;
> unsigned short quotalen;
> unsigned short datalen;
>
>
>
> short state;
>
>
>
>
>
>
> unsigned long flags;
># 239 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
> union {
>  struct keyring_index_key index_key;
>  struct {
>   unsigned long hash;
>   unsigned long len_desc;
>   struct key_type *type;
>   struct key_tag *domain_tag;
>   char *description;
>  };
> };
>
>
>
>
>
> union {
>  union key_payload payload;
>  struct {
>
>   struct list_head name_link;
>   struct assoc_array keys;
>  };
> };
># 274 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
> struct key_restriction *restrict_link;
>};
>
>extern struct key *key_alloc(struct key_type *type,
>        const char *desc,
>        kuid_t uid, kgid_t gid,
>        const struct cred *cred,
>        key_perm_t perm,
>        unsigned long flags,
>        struct key_restriction *restrict_link);
># 294 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>extern void key_revoke(struct key *key);
>extern void key_invalidate(struct key *key);
>extern void key_put(struct key *key);
>extern bool key_put_tag(struct key_tag *tag);
>extern void key_remove_domain(struct key_tag *domain_tag);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct key *__key_get(struct key *key)
>{
> refcount_inc(&key->usage);
> return key;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct key *key_get(struct key *key)
>{
> return key ? __key_get(key) : key;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void key_ref_put(key_ref_t key_ref)
>{
> key_put(key_ref_to_ptr(key_ref));
>}
>
>extern struct key *request_key_tag(struct key_type *type,
>       const char *description,
>       struct key_tag *domain_tag,
>       const char *callout_info);
>
>extern struct key *request_key_rcu(struct key_type *type,
>       const char *description,
>       struct key_tag *domain_tag);
>
>extern struct key *request_key_with_auxdata(struct key_type *type,
>         const char *description,
>         struct key_tag *domain_tag,
>         const void *callout_info,
>         size_t callout_len,
>         void *aux);
># 340 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct key *request_key(struct key_type *type,
>          const char *description,
>          const char *callout_info)
>{
> return request_key_tag(type, description, ((void *)0), callout_info);
>}
># 379 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>extern int wait_for_key_construction(struct key *key, bool intr);
>
>extern int key_validate(const struct key *key);
>
>extern key_ref_t key_create_or_update(key_ref_t keyring,
>          const char *type,
>          const char *description,
>          const void *payload,
>          size_t plen,
>          key_perm_t perm,
>          unsigned long flags);
>
>extern int key_update(key_ref_t key,
>        const void *payload,
>        size_t plen);
>
>extern int key_link(struct key *keyring,
>      struct key *key);
>
>extern int key_move(struct key *key,
>      struct key *from_keyring,
>      struct key *to_keyring,
>      unsigned int flags);
>
>extern int key_unlink(struct key *keyring,
>        struct key *key);
>
>extern struct key *keyring_alloc(const char *description, kuid_t uid, kgid_t gid,
>     const struct cred *cred,
>     key_perm_t perm,
>     unsigned long flags,
>     struct key_restriction *restrict_link,
>     struct key *dest);
>
>extern int restrict_link_reject(struct key *keyring,
>    const struct key_type *type,
>    const union key_payload *payload,
>    struct key *restriction_key);
>
>extern int keyring_clear(struct key *keyring);
>
>extern key_ref_t keyring_search(key_ref_t keyring,
>    struct key_type *type,
>    const char *description,
>    bool recurse);
>
>extern int keyring_add_key(struct key *keyring,
>      struct key *key);
>
>extern int keyring_restrict(key_ref_t keyring, const char *type,
>       const char *restriction);
>
>extern struct key *key_lookup(key_serial_t id);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) key_serial_t key_serial(const struct key *key)
>{
> return key ? key->serial : 0;
>}
>
>extern void key_set_timeout(struct key *, unsigned);
>
>extern key_ref_t lookup_user_key(key_serial_t id, unsigned long flags,
>     enum key_need_perm need_perm);
>extern void key_free_user_ns(struct user_namespace *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) short key_read_state(const struct key *key)
>{
>
> return ({ typeof(*&key->state) ___p1 = ({ do { extern void __compiletime_assert_217(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&key->state) == sizeof(char) || sizeof(*&key->state) == sizeof(short) || sizeof(*&key->state) == sizeof(int) || sizeof(*&key->state) == sizeof(long)) || sizeof(*&key->state) == sizeof(long long))) __compiletime_assert_217(); } while (0); (*(const volatile typeof( _Generic((*&key->state), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&key->state))) *)&(*&key->state)); }); do { extern void __compiletime_assert_218(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&key->state) == sizeof(char) || sizeof(*&key->state) == sizeof(short) || sizeof(*&key->state) == sizeof(int) || sizeof(*&key->state) == sizeof(long)))) __compiletime_assert_218(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
>}
># 457 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool key_is_positive(const struct key *key)
>{
> return key_read_state(key) == KEY_IS_POSITIVE;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool key_is_negative(const struct key *key)
>{
> return key_read_state(key) < 0;
>}
># 480 "/usr/src/linux-5.14.21-150500.53/include/linux/key.h"
>extern struct ctl_table key_sysctls[];
>
>
>
>
>extern int install_thread_keyring_to_cred(struct cred *cred);
>extern void key_fsuid_changed(struct cred *new_cred);
>extern void key_fsgid_changed(struct cred *new_cred);
>extern void key_init(void);
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/user.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu_counter.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu_counter.h"
>struct percpu_counter {
> raw_spinlock_t lock;
> s64 count;
>
> struct list_head list;
>
> s32 *counters;
>};
>
>extern int percpu_counter_batch;
>
>int __percpu_counter_init(struct percpu_counter *fbc, s64 amount, gfp_t gfp,
>     struct lock_class_key *key);
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu_counter.h"
>void percpu_counter_destroy(struct percpu_counter *fbc);
>void percpu_counter_set(struct percpu_counter *fbc, s64 amount);
>void percpu_counter_add_batch(struct percpu_counter *fbc, s64 amount,
>         s32 batch);
>s64 __percpu_counter_sum(struct percpu_counter *fbc);
>int __percpu_counter_compare(struct percpu_counter *fbc, s64 rhs, s32 batch);
>void percpu_counter_sync(struct percpu_counter *fbc);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int percpu_counter_compare(struct percpu_counter *fbc, s64 rhs)
>{
> return __percpu_counter_compare(fbc, rhs, percpu_counter_batch);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_counter_add(struct percpu_counter *fbc, s64 amount)
>{
> percpu_counter_add_batch(fbc, amount, percpu_counter_batch);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 percpu_counter_sum_positive(struct percpu_counter *fbc)
>{
> s64 ret = __percpu_counter_sum(fbc);
> return ret < 0 ? 0 : ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 percpu_counter_sum(struct percpu_counter *fbc)
>{
> return __percpu_counter_sum(fbc);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 percpu_counter_read(struct percpu_counter *fbc)
>{
> return fbc->count;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s64 percpu_counter_read_positive(struct percpu_counter *fbc)
>{
>
> s64 ret = ({ do { extern void __compiletime_assert_219(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(fbc->count) == sizeof(char) || sizeof(fbc->count) == sizeof(short) || sizeof(fbc->count) == sizeof(int) || sizeof(fbc->count) == sizeof(long)) || sizeof(fbc->count) == sizeof(long long))) __compiletime_assert_219(); } while (0); (*(const volatile typeof( _Generic((fbc->count), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (fbc->count))) *)&(fbc->count)); });
>
> if (ret >= 0)
>  return ret;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_counter_initialized(struct percpu_counter *fbc)
>{
> return (fbc->counters != ((void *)0));
>}
># 181 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu_counter.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_counter_inc(struct percpu_counter *fbc)
>{
> percpu_counter_add(fbc, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_counter_dec(struct percpu_counter *fbc)
>{
> percpu_counter_add(fbc, -1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_counter_sub(struct percpu_counter *fbc, s64 amount)
>{
> percpu_counter_add(fbc, -amount);
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/user.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ratelimit.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/ratelimit.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ratelimit_state_init(struct ratelimit_state *rs,
>     int interval, int burst)
>{
> memset(rs, 0, sizeof(*rs));
>
> do { *(&rs->lock) = (raw_spinlock_t) { .raw_lock = { { .val = { (0) } } }, }; } while (0);
> rs->interval = interval;
> rs->burst = burst;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ratelimit_default_init(struct ratelimit_state *rs)
>{
> return ratelimit_state_init(rs, (5 * 250),
>     10);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ratelimit_state_exit(struct ratelimit_state *rs)
>{
> if (!(rs->flags & ((((1UL))) << (0))))
>  return;
>
> if (rs->missed) {
>  printk("\001" "4" "%s: %d output lines suppressed due to ratelimiting\n", get_current()->comm, rs->missed)
>                             ;
>  rs->missed = 0;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>ratelimit_set_flags(struct ratelimit_state *rs, unsigned long flags)
>{
> rs->flags = flags;
>}
>
>extern struct ratelimit_state printk_ratelimit_state;
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/user.h" 2
>
>
>
>
>struct user_struct {
> refcount_t __count;
>
> struct percpu_counter epoll_watches;
>
> unsigned long unix_inflight;
> atomic_long_t pipe_bufs;
>
>
> struct hlist_node uidhash_node;
> kuid_t uid;
>
>
>
>
> atomic_long_t locked_vm;
>
>
> atomic_t nr_watches;
>
>
>
> struct ratelimit_state ratelimit;
>};
>
>extern int uids_sysfs_init(void);
>
>extern struct user_struct *find_user(kuid_t);
>
>extern struct user_struct root_user;
>
>
>
>
>extern struct user_struct * alloc_uid(kuid_t);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct user_struct *get_uid(struct user_struct *u)
>{
> refcount_inc(&u->__count);
> return u;
>}
>extern void free_uid(struct user_struct *);
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h" 2
>
>struct cred;
>struct inode;
>
>
>
>
>struct group_info {
> atomic_t usage;
> int ngroups;
> kgid_t gid[];
>} __attribute__((__designated_init__));
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct group_info *get_group_info(struct group_info *gi)
>{
> atomic_inc(&gi->usage);
> return gi;
>}
># 57 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>extern struct group_info *groups_alloc(int);
>extern void groups_free(struct group_info *);
>
>extern int in_group_p(kgid_t);
>extern int in_egroup_p(kgid_t);
>extern int groups_search(const struct group_info *, kgid_t);
>
>extern int set_current_groups(struct group_info *);
>extern void set_groups(struct cred *, struct group_info *);
>extern bool may_setgroups(void);
>extern void groups_sort(struct group_info *);
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>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 securebits;
> kernel_cap_t cap_inheritable;
> kernel_cap_t cap_permitted;
> kernel_cap_t cap_effective;
> kernel_cap_t cap_bset;
> kernel_cap_t cap_ambient;
>
> unsigned char jit_keyring;
>
> struct key *session_keyring;
> struct key *process_keyring;
> struct key *thread_keyring;
> struct key *request_key_auth;
>
>
> void *security;
>
> struct user_struct *user;
> struct user_namespace *user_ns;
> struct ucounts *ucounts;
> struct group_info *group_info;
>
> union {
>  int non_rcu;
>  struct callback_head rcu;
> };
>} __attribute__((__designated_init__));
>
>extern void __put_cred(struct cred *);
>extern void exit_creds(struct task_struct *);
>extern int copy_creds(struct task_struct *, unsigned long);
>extern const struct cred *get_task_cred(struct task_struct *);
>extern struct cred *cred_alloc_blank(void);
>extern struct cred *prepare_creds(void);
>extern struct cred *prepare_exec_creds(void);
>extern int commit_creds(struct cred *);
>extern void abort_creds(struct cred *);
>extern const struct cred *override_creds(const struct cred *);
>extern void revert_creds(const struct cred *);
>extern struct cred *prepare_kernel_cred(struct task_struct *);
>extern int change_create_files_as(struct cred *, struct inode *);
>extern int set_security_override(struct cred *, u32);
>extern int set_security_override_from_ctx(struct cred *, const char *);
>extern int set_create_files_as(struct cred *, struct inode *);
>extern int cred_fscmp(const struct cred *, const struct cred *);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) cred_init(void);
>extern int set_cred_ucounts(struct cred *);
># 204 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void validate_creds(const struct cred *cred)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void validate_creds_for_do_exit(struct task_struct *tsk)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void validate_process_creds(void)
>{
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cap_ambient_invariant_ok(const struct cred *cred)
>{
> return cap_issubset(cred->cap_ambient,
>       cap_intersect(cred->cap_permitted,
>       cred->cap_inheritable));
>}
># 229 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cred *get_new_cred(struct cred *cred)
>{
> atomic_inc(&cred->usage);
> return cred;
>}
># 248 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cred *get_cred(const struct cred *cred)
>{
> struct cred *nonconst_cred = (struct cred *) cred;
> if (!cred)
>  return cred;
> validate_creds(cred);
> nonconst_cred->non_rcu = 0;
> return get_new_cred(nonconst_cred);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cred *get_cred_rcu(const struct cred *cred)
>{
> struct cred *nonconst_cred = (struct cred *) cred;
> if (!cred)
>  return ((void *)0);
> if (!atomic_inc_not_zero(&nonconst_cred->usage))
>  return ((void *)0);
> validate_creds(cred);
> nonconst_cred->non_rcu = 0;
> return cred;
>}
># 281 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_cred(const struct cred *_cred)
>{
> struct cred *cred = (struct cred *) _cred;
>
> if (cred) {
>  validate_creds(cred);
>  if (atomic_dec_and_test(&(cred)->usage))
>   __put_cred(cred);
> }
>}
># 393 "/usr/src/linux-5.14.21-150500.53/include/linux/cred.h"
>extern struct user_namespace init_user_ns;
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h" 2
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>struct sighand_struct {
> spinlock_t siglock;
> refcount_t count;
> wait_queue_head_t signalfd_wqh;
> struct k_sigaction action[64];
>};
>
>
>
>
>struct pacct_struct {
> int ac_flag;
> long ac_exitcode;
> unsigned long ac_mem;
> u64 ac_utime, ac_stime;
> unsigned long ac_minflt, ac_majflt;
>};
>
>struct cpu_itimer {
> u64 expires;
> u64 incr;
>};
>
>
>
>
>
>struct task_cputime_atomic {
> atomic64_t utime;
> atomic64_t stime;
> atomic64_t sum_exec_runtime;
>};
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>struct thread_group_cputimer {
> struct task_cputime_atomic cputime_atomic;
>};
>
>struct multiprocess_signals {
> sigset_t signal;
> struct hlist_node node;
>};
># 82 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>struct signal_struct {
> refcount_t sigcnt;
> atomic_t live;
> int nr_threads;
> struct list_head thread_head;
>
> wait_queue_head_t wait_chldexit;
>
>
> struct task_struct *curr_target;
>
>
> struct sigpending shared_pending;
>
>
> struct hlist_head multiprocess;
>
>
> int group_exit_code;
>
>
>
>
>
> int notify_count;
> struct task_struct *group_exit_task;
>
>
> int group_stop_count;
> unsigned int flags;
># 122 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
> 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;
> ktime_t it_real_incr;
>
>
>
>
>
>
> struct cpu_itimer it[2];
>
>
>
>
>
> struct thread_group_cputimer cputimer;
>
>
>
> struct posix_cputimers posix_cputimers;
>
>
> struct pid *pids[PIDTYPE_MAX];
>
>
> atomic_t tick_dep_mask;
>
>
> struct pid *tty_old_pgrp;
>
>
> int leader;
>
> struct tty_struct *tty;
># 175 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
> seqlock_t stats_lock;
> u64 utime, stime, cutime, cstime;
> u64 gtime;
> u64 cgtime;
> struct prev_cputime prev_cputime;
> unsigned long nvcsw, nivcsw, cnvcsw, cnivcsw;
> unsigned long min_flt, maj_flt, cmin_flt, cmaj_flt;
> unsigned long inblock, oublock, cinblock, coublock;
> unsigned long maxrss, cmaxrss;
> struct task_io_accounting ioac;
>
>
>
>
>
>
>
> unsigned long long sum_sched_runtime;
># 203 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
> struct rlimit rlim[16];
>
>
> struct pacct_struct pacct;
>
>
> struct taskstats *stats;
>
>
> unsigned audit_tty;
> struct tty_audit_buf *tty_audit_buf;
>
>
>
>
>
>
> bool oom_flag_origin;
> short oom_score_adj;
> short oom_score_adj_min;
>
> struct mm_struct *oom_mm;
>
>
> struct mutex cred_guard_mutex;
>
>
>
>
>
> struct rw_semaphore exec_update_lock;
>
>
>
>
> void *suse_kabi_padding;
>} __attribute__((__designated_init__));
># 260 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void signal_set_stop_flags(struct signal_struct *sig,
>      unsigned int flags)
>{
> ({ int __ret_warn_on = !!(sig->flags & (0x00000004|0x00000008)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"), "i" (263), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("220" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "220" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> sig->flags = (sig->flags & ~((0x00000010|0x00000020) | 0x00000001 | 0x00000002)) | flags;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int signal_group_exit(const struct signal_struct *sig)
>{
> return (sig->flags & 0x00000004) ||
>  (sig->group_exit_task != ((void *)0));
>}
>
>extern void flush_signals(struct task_struct *);
>extern void ignore_signals(struct task_struct *);
>extern void flush_signal_handlers(struct task_struct *, int force_default);
>extern int dequeue_signal(struct task_struct *task,
>     sigset_t *mask, kernel_siginfo_t *info);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kernel_dequeue_signal(void)
>{
> struct task_struct *task = get_current();
> kernel_siginfo_t __info;
> int ret;
>
> spin_lock_irq(&task->sighand->siglock);
> ret = dequeue_signal(task, &task->blocked, &__info);
> spin_unlock_irq(&task->sighand->siglock);
>
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kernel_signal_stop(void)
>{
> spin_lock_irq(&get_current()->sighand->siglock);
> if (get_current()->jobctl & (1UL << 16))
>  do { unsigned long flags; do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(&get_current()->pi_lock); } while (0); do { } while (0); do { do { extern void __compiletime_assert_221(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(get_current()->__state) == sizeof(char) || sizeof(get_current()->__state) == sizeof(short) || sizeof(get_current()->__state) == sizeof(int) || sizeof(get_current()->__state) == sizeof(long)) || sizeof(get_current()->__state) == sizeof(long long))) __compiletime_assert_221(); } while (0); do { *(volatile typeof(get_current()->__state) *)&(get_current()->__state) = (((0x0100 | 0x0004))); } while (0); } while (0); do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _raw_spin_unlock_irqrestore(&get_current()->pi_lock, flags); } while (0); } while (0);
> spin_unlock_irq(&get_current()->sighand->siglock);
>
> schedule();
>}
># 313 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>int force_sig_fault_to_task(int sig, int code, void *addr
>
>
> , struct task_struct *t);
>int force_sig_fault(int sig, int code, void *addr
>
> );
>int send_sig_fault(int sig, int code, void *addr
>
>
> , struct task_struct *t);
>
>int force_sig_mceerr(int code, void *, short);
>int send_sig_mceerr(int code, void *, short, struct task_struct *);
>
>int force_sig_bnderr(void *addr, void *lower, void *upper);
>int force_sig_pkuerr(void *addr, u32 pkey);
>int send_sig_perf(void *addr, u32 type, u64 sig_data);
>
>int force_sig_ptrace_errno_trap(int errno, void *addr);
>int force_sig_fault_trapno(int sig, int code, void *addr, int trapno);
>
>extern int send_sig_info(int, struct kernel_siginfo *, struct task_struct *);
>extern void force_sigsegv(int sig);
>extern int force_sig_info(struct kernel_siginfo *);
>extern int __kill_pgrp_info(int sig, struct kernel_siginfo *info, struct pid *pgrp);
>extern int kill_pid_info(int sig, struct kernel_siginfo *info, struct pid *pid);
>extern int kill_pid_usb_asyncio(int sig, int errno, sigval_t addr, struct pid *,
>    const struct cred *);
>extern int kill_pgrp(struct pid *pid, int sig, int priv);
>extern int kill_pid(struct pid *pid, int sig, int priv);
>extern __attribute__((__warn_unused_result__)) bool do_notify_parent(struct task_struct *, int);
>extern void __wake_up_parent(struct task_struct *p, struct task_struct *parent);
>extern void force_sig(int);
>extern int send_sig(int, struct task_struct *, int);
>extern int zap_other_threads(struct task_struct *p);
>extern struct sigqueue *sigqueue_alloc(void);
>extern void sigqueue_free(struct sigqueue *);
>extern int send_sigqueue(struct sigqueue *, struct pid *, enum pid_type);
>extern int do_sigaction(int, struct k_sigaction *, struct k_sigaction *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int restart_syscall(void)
>{
> set_tsk_thread_flag(get_current(), 2);
> return -513;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int task_sigpending(struct task_struct *p)
>{
> return __builtin_expect(!!(test_tsk_thread_flag(p,2)), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int signal_pending(struct task_struct *p)
>{
>
>
>
>
>
> if (__builtin_expect(!!(test_tsk_thread_flag(p, 17)), 0))
>  return 1;
> return task_sigpending(p);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __fatal_signal_pending(struct task_struct *p)
>{
> return __builtin_expect(!!(sigismember(&p->pending.signal, 9)), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fatal_signal_pending(struct task_struct *p)
>{
> return task_sigpending(p) && __fatal_signal_pending(p);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int signal_pending_state(unsigned int state, struct task_struct *p)
>{
> if (!(state & (0x0001 | 0x0100)))
>  return 0;
> if (!signal_pending(p))
>  return 0;
>
> return (state & 0x0001) || __fatal_signal_pending(p);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fault_signal_pending(vm_fault_t fault_flags,
>     struct pt_regs *regs)
>{
> return __builtin_expect(!!((fault_flags & VM_FAULT_RETRY) && (fatal_signal_pending(get_current()) || (user_mode(regs) && signal_pending(get_current())))), 0)
>
>                                                  ;
>}
>
>
>
>
>
>
>
>extern void recalc_sigpending_and_wake(struct task_struct *t);
>extern void recalc_sigpending(void);
>extern void calculate_sigpending(void);
>
>extern void signal_wake_up_state(struct task_struct *t, unsigned int state);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void signal_wake_up(struct task_struct *t, bool resume)
>{
> signal_wake_up_state(t, resume ? 0x0100 : 0);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptrace_signal_wake_up(struct task_struct *t, bool resume)
>{
> signal_wake_up_state(t, resume ? 0x0008 : 0);
>}
>
>void task_join_group_stop(struct task_struct *task);
># 481 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_restore_sigmask(void)
>{
> get_current()->restore_sigmask = true;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_tsk_restore_sigmask(struct task_struct *task)
>{
> task->restore_sigmask = false;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_restore_sigmask(void)
>{
> get_current()->restore_sigmask = false;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_restore_sigmask(void)
>{
> return get_current()->restore_sigmask;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_tsk_restore_sigmask(struct task_struct *task)
>{
> return task->restore_sigmask;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool test_and_clear_restore_sigmask(void)
>{
> if (!get_current()->restore_sigmask)
>  return false;
> get_current()->restore_sigmask = false;
> return true;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void restore_saved_sigmask(void)
>{
> if (test_and_clear_restore_sigmask())
>  __set_current_blocked(&get_current()->saved_sigmask);
>}
>
>extern int set_user_sigmask(const sigset_t *umask, size_t sigsetsize);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void restore_saved_sigmask_unless(bool interrupted)
>{
> if (interrupted)
>  ({ int __ret_warn_on = !!(!signal_pending(get_current())); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"), "i" (521), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("222" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "222" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> else
>  restore_saved_sigmask();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) sigset_t *sigmask_to_save(void)
>{
> sigset_t *res = &get_current()->blocked;
> if (__builtin_expect(!!(test_restore_sigmask()), 0))
>  res = &get_current()->saved_sigmask;
> return res;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kill_cad_pid(int sig, int priv)
>{
> return kill_pid(cad_pid, sig, priv);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __on_sig_stack(unsigned long sp)
>{
>
>
>
>
> return sp > get_current()->sas_ss_sp &&
>  sp - get_current()->sas_ss_sp <= get_current()->sas_ss_size;
>
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int on_sig_stack(unsigned long sp)
>{
># 568 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
> if (get_current()->sas_ss_flags & (1U << 31))
>  return 0;
>
> return __on_sig_stack(sp);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sas_ss_flags(unsigned long sp)
>{
> if (!get_current()->sas_ss_size)
>  return 2;
>
> return on_sig_stack(sp) ? 1 : 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sas_ss_reset(struct task_struct *p)
>{
> p->sas_ss_sp = 0;
> p->sas_ss_size = 0;
> p->sas_ss_flags = 2;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long sigsp(unsigned long sp, struct ksignal *ksig)
>{
> if (__builtin_expect(!!((ksig->ka.sa.sa_flags & 0x08000000)), 0) && ! sas_ss_flags(sp))
>
>
>
>  return get_current()->sas_ss_sp + get_current()->sas_ss_size;
>
> return sp;
>}
>
>extern void __cleanup_sighand(struct sighand_struct *);
>extern void flush_itimer_signals(void);
># 612 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>extern bool current_is_single_threaded(void);
># 634 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/signal.h"
>typedef int (*proc_visitor)(struct task_struct *p, void *data);
>void walk_process_tree(struct task_struct *top, proc_visitor, void *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct pid *task_pid_type(struct task_struct *task, enum pid_type type)
>{
> struct pid *pid;
> if (type == PIDTYPE_PID)
>  pid = task_pid(task);
> else
>  pid = task->signal->pids[type];
> return pid;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid *task_tgid(struct task_struct *task)
>{
> return task->signal->pids[PIDTYPE_TGID];
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid *task_pgrp(struct task_struct *task)
>{
> return task->signal->pids[PIDTYPE_PGID];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid *task_session(struct task_struct *task)
>{
> return task->signal->pids[PIDTYPE_SID];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_nr_threads(struct task_struct *task)
>{
> return task->signal->nr_threads;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool thread_group_leader(struct task_struct *p)
>{
> return p->exit_signal >= 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>bool same_thread_group(struct task_struct *p1, struct task_struct *p2)
>{
> return p1->signal == p2->signal;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct task_struct *next_thread(const struct task_struct *p)
>{
> return ({ void *__mptr = (void *)(({ do { extern void __compiletime_assert_223(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(p->thread_group.next) == sizeof(char) || sizeof(p->thread_group.next) == sizeof(short) || sizeof(p->thread_group.next) == sizeof(int) || sizeof(p->thread_group.next) == sizeof(long)) || sizeof(p->thread_group.next) == sizeof(long long))) __compiletime_assert_223(); } while (0); (*(const volatile typeof( _Generic((p->thread_group.next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (p->thread_group.next))) *)&(p->thread_group.next)); })); do { extern void __compiletime_assert_224(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(({ do { extern void __compiletime_assert_223(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(p->thread_group.next) == sizeof(char) || sizeof(p->thread_group.next) == sizeof(short) || sizeof(p->thread_group.next) == sizeof(int) || sizeof(p->thread_group.next) == sizeof(long)) || sizeof(p->thread_group.next) == sizeof(long long))) __compiletime_assert_223(); } while (0); (*(const volatile typeof( _Generic((p->thread_group.next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (p->thread_group.next))) *)&(p->thread_group.next)); }))), typeof(((struct task_struct *)0)->thread_group)) && !__builtin_types_compatible_p(typeof(*(({ do { extern void __compiletime_assert_223(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(p->thread_group.next) == sizeof(char) || sizeof(p->thread_group.next) == sizeof(short) || sizeof(p->thread_group.next) == sizeof(int) || sizeof(p->thread_group.next) == sizeof(long)) || sizeof(p->thread_group.next) == sizeof(long long))) __compiletime_assert_223(); } while (0); (*(const volatile typeof( _Generic((p->thread_group.next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (p->thread_group.next))) *)&(p->thread_group.next)); }))), typeof(void))))) __compiletime_assert_224(); } while (0); ((struct task_struct *)(__mptr - __builtin_offsetof(struct task_struct, thread_group))); })
>                                          ;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int thread_group_empty(struct task_struct *p)
>{
> return list_empty(&p->thread_group);
>}
>
>
>
>
>extern bool thread_group_exited(struct pid *pid);
>
>extern struct sighand_struct *__lock_task_sighand(struct task_struct *task,
>       unsigned long *flags);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct sighand_struct *lock_task_sighand(struct task_struct *task,
>             unsigned long *flags)
>{
> struct sighand_struct *ret;
>
> ret = __lock_task_sighand(task, flags);
> (void)(ret);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unlock_task_sighand(struct task_struct *task,
>      unsigned long *flags)
>{
> spin_unlock_irqrestore(&task->sighand->siglock, *flags);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_assert_task_sighand_held(struct task_struct *task) { }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long task_rlimit(const struct task_struct *task,
>  unsigned int limit)
>{
> return ({ do { extern void __compiletime_assert_225(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(task->signal->rlim[limit].rlim_cur) == sizeof(char) || sizeof(task->signal->rlim[limit].rlim_cur) == sizeof(short) || sizeof(task->signal->rlim[limit].rlim_cur) == sizeof(int) || sizeof(task->signal->rlim[limit].rlim_cur) == sizeof(long)) || sizeof(task->signal->rlim[limit].rlim_cur) == sizeof(long long))) __compiletime_assert_225(); } while (0); (*(const volatile typeof( _Generic((task->signal->rlim[limit].rlim_cur), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (task->signal->rlim[limit].rlim_cur))) *)&(task->signal->rlim[limit].rlim_cur)); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long task_rlimit_max(const struct task_struct *task,
>  unsigned int limit)
>{
> return ({ do { extern void __compiletime_assert_226(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(task->signal->rlim[limit].rlim_max) == sizeof(char) || sizeof(task->signal->rlim[limit].rlim_max) == sizeof(short) || sizeof(task->signal->rlim[limit].rlim_max) == sizeof(int) || sizeof(task->signal->rlim[limit].rlim_max) == sizeof(long)) || sizeof(task->signal->rlim[limit].rlim_max) == sizeof(long long))) __compiletime_assert_226(); } while (0); (*(const volatile typeof( _Generic((task->signal->rlim[limit].rlim_max), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (task->signal->rlim[limit].rlim_max))) *)&(task->signal->rlim[limit].rlim_max)); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long rlimit(unsigned int limit)
>{
> return task_rlimit(get_current(), limit);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long rlimit_max(unsigned int limit)
>{
> return task_rlimit_max(get_current(), limit);
>}
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/rcuwait.h" 2
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/rcuwait.h"
>struct rcuwait {
> struct task_struct *task;
>};
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void rcuwait_init(struct rcuwait *w)
>{
> w->task = ((void *)0);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rcuwait_active(struct rcuwait *w)
>{
> return !!({ typeof(*(w->task)) *_________p1 = (typeof(*(w->task)) *)({ do { extern void __compiletime_assert_227(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((w->task)) == sizeof(char) || sizeof((w->task)) == sizeof(short) || sizeof((w->task)) == sizeof(int) || sizeof((w->task)) == sizeof(long)) || sizeof((w->task)) == sizeof(long long))) __compiletime_assert_227(); } while (0); (*(const volatile typeof( _Generic(((w->task)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((w->task)))) *)&((w->task))); }); ; ((typeof(*(w->task)) *)(_________p1)); });
>}
>
>extern int rcuwait_wake_up(struct rcuwait *w);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void prepare_to_rcuwait(struct rcuwait *w)
>{
> do { uintptr_t _r_a_p__v = (uintptr_t)(get_current()); ; if (__builtin_constant_p(get_current()) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_228(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((w->task)) == sizeof(char) || sizeof((w->task)) == sizeof(short) || sizeof((w->task)) == sizeof(int) || sizeof((w->task)) == sizeof(long)) || sizeof((w->task)) == sizeof(long long))) __compiletime_assert_228(); } while (0); do { *(volatile typeof((w->task)) *)&((w->task)) = ((typeof(w->task))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_229(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&w->task) == sizeof(char) || sizeof(*&w->task) == sizeof(short) || sizeof(*&w->task) == sizeof(int) || sizeof(*&w->task) == sizeof(long)))) __compiletime_assert_229(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_230(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&w->task) == sizeof(char) || sizeof(*&w->task) == sizeof(short) || sizeof(*&w->task) == sizeof(int) || sizeof(*&w->task) == sizeof(long)) || sizeof(*&w->task) == sizeof(long long))) __compiletime_assert_230(); } while (0); do { *(volatile typeof(*&w->task) *)&(*&w->task) = ((typeof(*((typeof(w->task))_r_a_p__v)) *)((typeof(w->task))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void finish_rcuwait(struct rcuwait *w)
>{
>        do { uintptr_t _r_a_p__v = (uintptr_t)(((void *)0)); ; if (__builtin_constant_p(((void *)0)) && (_r_a_p__v) == (uintptr_t)((void *)0)) do { do { extern void __compiletime_assert_231(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((w->task)) == sizeof(char) || sizeof((w->task)) == sizeof(short) || sizeof((w->task)) == sizeof(int) || sizeof((w->task)) == sizeof(long)) || sizeof((w->task)) == sizeof(long long))) __compiletime_assert_231(); } while (0); do { *(volatile typeof((w->task)) *)&((w->task)) = ((typeof(w->task))(_r_a_p__v)); } while (0); } while (0); else do { do { extern void __compiletime_assert_232(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&w->task) == sizeof(char) || sizeof(*&w->task) == sizeof(short) || sizeof(*&w->task) == sizeof(int) || sizeof(*&w->task) == sizeof(long)))) __compiletime_assert_232(); } while (0); __asm__ __volatile__("": : :"memory"); do { do { extern void __compiletime_assert_233(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&w->task) == sizeof(char) || sizeof(*&w->task) == sizeof(short) || sizeof(*&w->task) == sizeof(int) || sizeof(*&w->task) == sizeof(long)) || sizeof(*&w->task) == sizeof(long long))) __compiletime_assert_233(); } while (0); do { *(volatile typeof(*&w->task) *)&(*&w->task) = ((typeof(*((typeof(w->task))_r_a_p__v)) *)((typeof(w->task))_r_a_p__v)); } while (0); } while (0); } while (0); } while (0);
> do { do { } while (0); do { do { extern void __compiletime_assert_234(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(get_current()->__state) == sizeof(char) || sizeof(get_current()->__state) == sizeof(short) || sizeof(get_current()->__state) == sizeof(int) || sizeof(get_current()->__state) == sizeof(long)) || sizeof(get_current()->__state) == sizeof(long long))) __compiletime_assert_234(); } while (0); do { *(volatile typeof(get_current()->__state) *)&(get_current()->__state) = ((0x0000)); } while (0); } while (0); } while (0);
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-rwsem.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_sync.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_sync.h"
>struct rcu_sync {
> int gp_state;
> int gp_count;
> wait_queue_head_t gp_wait;
>
> struct callback_head cb_head;
>};
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/rcu_sync.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool rcu_sync_is_idle(struct rcu_sync *rsp)
>{
> do { } while (0 && (!rcu_read_lock_any_held()))
>                                          ;
> return !({ do { extern void __compiletime_assert_235(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(rsp->gp_state) == sizeof(char) || sizeof(rsp->gp_state) == sizeof(short) || sizeof(rsp->gp_state) == sizeof(int) || sizeof(rsp->gp_state) == sizeof(long)) || sizeof(rsp->gp_state) == sizeof(long long))) __compiletime_assert_235(); } while (0); (*(const volatile typeof( _Generic((rsp->gp_state), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (rsp->gp_state))) *)&(rsp->gp_state)); });
>}
>
>extern void rcu_sync_init(struct rcu_sync *);
>extern void rcu_sync_enter_start(struct rcu_sync *);
>extern void rcu_sync_enter(struct rcu_sync *);
>extern void rcu_sync_exit(struct rcu_sync *);
>extern void rcu_sync_dtor(struct rcu_sync *);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-rwsem.h" 2
>
>
>struct percpu_rw_semaphore {
> struct rcu_sync rss;
> unsigned int *read_count;
> struct rcuwait writer;
> wait_queue_head_t waiters;
> atomic_t block;
>
>
>
>};
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-rwsem.h"
>extern bool __percpu_down_read(struct percpu_rw_semaphore *, bool);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_down_read(struct percpu_rw_semaphore *sem)
>{
> do { might_resched(); } while (0);
>
> do { } while (0);
>
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-rwsem.h"
> if (__builtin_expect(!!(rcu_sync_is_idle(&sem->rss)), 1))
>  do { do { const void *__vpp_verify = (typeof((&(*sem->read_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*sem->read_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
> else
>  __percpu_down_read(sem, false);
>
>
>
>
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool percpu_down_read_trylock(struct percpu_rw_semaphore *sem)
>{
> bool ret = true;
>
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
>
>
>
> if (__builtin_expect(!!(rcu_sync_is_idle(&sem->rss)), 1))
>  do { do { const void *__vpp_verify = (typeof((&(*sem->read_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*sem->read_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
> else
>  ret = __percpu_down_read(sem, true);
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>
>
>
>
>
> if (ret)
>  do { } while (0);
>
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_up_read(struct percpu_rw_semaphore *sem)
>{
> do { } while (0);
>
> do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
>
>
>
> if (__builtin_expect(!!(rcu_sync_is_idle(&sem->rss)), 1)) {
>  do { do { const void *__vpp_verify = (typeof((&(*sem->read_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*sem->read_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) -(typeof(*sem->read_count))(1)) & 0xff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) -(typeof(*sem->read_count))(1)) & 0xffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) -(typeof(*sem->read_count))(1)) & 0xffffffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u64 pto_val__ = ((u64)(-(typeof(*sem->read_count))(1))); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
> } else {
>
>
>
>
>  asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
>
>
>
>
>
>  do { do { const void *__vpp_verify = (typeof((&(*sem->read_count)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(*sem->read_count)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) -(typeof(*sem->read_count))(1)) & 0xff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) -(typeof(*sem->read_count))(1)) & 0xffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) -(typeof(*sem->read_count))(1)) & 0xffffffff)); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(*sem->read_count))(1)) && ((-(typeof(*sem->read_count))(1)) == 1 || (-(typeof(*sem->read_count))(1)) == -1)) ? (int)(-(typeof(*sem->read_count))(1)) : 0; if (0) { typeof((*sem->read_count)) pao_tmp__; pao_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count))); }); else do { u64 pto_val__ = ((u64)(-(typeof(*sem->read_count))(1))); if (0) { typeof((*sem->read_count)) pto_tmp__; pto_tmp__ = (-(typeof(*sem->read_count))(1)); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((*sem->read_count)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>  rcuwait_wake_up(&sem->writer);
> }
> do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>extern void percpu_down_write(struct percpu_rw_semaphore *);
>extern void percpu_up_write(struct percpu_rw_semaphore *);
>
>extern int __percpu_init_rwsem(struct percpu_rw_semaphore *,
>    const char *, struct lock_class_key *);
>
>extern void percpu_free_rwsem(struct percpu_rw_semaphore *);
># 141 "/usr/src/linux-5.14.21-150500.53/include/linux/percpu-rwsem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_rwsem_release(struct percpu_rw_semaphore *sem,
>     bool read, unsigned long ip)
>{
> do { } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void percpu_rwsem_acquire(struct percpu_rw_semaphore *sem,
>     bool read, unsigned long ip)
>{
> do { } while (0);
>}
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/delayed_call.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/delayed_call.h"
>struct delayed_call {
> void (*fn)(void *);
> void *arg;
>};
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_delayed_call(struct delayed_call *call,
>  void (*fn)(void *), void *arg)
>{
> call->fn = fn;
> call->arg = arg;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void do_delayed_call(struct delayed_call *call)
>{
> if (call->fn)
>  call->fn(call->arg);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_delayed_call(struct delayed_call *call)
>{
> call->fn = ((void *)0);
>}
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/uuid.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/uuid.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/uuid.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/uuid.h"
>typedef struct {
> __u8 b[16];
>} guid_t;
># 35 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/uuid.h"
>typedef guid_t uuid_le;
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/uuid.h" 2
>
>
>
>
>typedef struct {
> __u8 b[16];
>} uuid_t;
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/uuid.h"
>extern const guid_t guid_null;
>extern const uuid_t uuid_null;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool guid_equal(const guid_t *u1, const guid_t *u2)
>{
> return memcmp(u1, u2, sizeof(guid_t)) == 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void guid_copy(guid_t *dst, const guid_t *src)
>{
> memcpy(dst, src, sizeof(guid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void import_guid(guid_t *dst, const __u8 *src)
>{
> memcpy(dst, src, sizeof(guid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void export_guid(__u8 *dst, const guid_t *src)
>{
> memcpy(dst, src, sizeof(guid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool guid_is_null(const guid_t *guid)
>{
> return guid_equal(guid, &guid_null);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uuid_equal(const uuid_t *u1, const uuid_t *u2)
>{
> return memcmp(u1, u2, sizeof(uuid_t)) == 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void uuid_copy(uuid_t *dst, const uuid_t *src)
>{
> memcpy(dst, src, sizeof(uuid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void import_uuid(uuid_t *dst, const __u8 *src)
>{
> memcpy(dst, src, sizeof(uuid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void export_uuid(__u8 *dst, const uuid_t *src)
>{
> memcpy(dst, src, sizeof(uuid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool uuid_is_null(const uuid_t *uuid)
>{
> return uuid_equal(uuid, &uuid_null);
>}
>
>void generate_random_uuid(unsigned char uuid[16]);
>void generate_random_guid(unsigned char guid[16]);
>
>extern void guid_gen(guid_t *u);
>extern void uuid_gen(uuid_t *u);
>
>bool __attribute__((__warn_unused_result__)) uuid_is_valid(const char *uuid);
>
>extern const u8 guid_index[16];
>extern const u8 uuid_index[16];
>
>int guid_parse(const char *uuid, guid_t *u);
>int uuid_parse(const char *uuid, uuid_t *u);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int uuid_le_cmp(const guid_t u1, const guid_t u2)
>{
> return memcmp(&u1, &u2, sizeof(guid_t));
>}
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/errseq.h" 1
>
>
>
>
>
>
>
>typedef u32 errseq_t;
>
>errseq_t errseq_set(errseq_t *eseq, int err);
>errseq_t errseq_sample(errseq_t *eseq);
>int errseq_check(errseq_t *eseq, errseq_t since);
>int errseq_check_and_advance(errseq_t *eseq, errseq_t *since);
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ioprio.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/rt.h" 1
>
>
>
>
>
>
>struct task_struct;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rt_prio(int prio)
>{
> if (__builtin_expect(!!(prio < 100), 0))
>  return 1;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int rt_task(struct task_struct *p)
>{
> return rt_prio(p->prio);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_is_realtime(struct task_struct *tsk)
>{
> int policy = tsk->policy;
>
> if (policy == 1 || policy == 2)
>  return true;
> if (policy == 6)
>  return true;
> return false;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct task_struct *rt_mutex_get_top_task(struct task_struct *p)
>{
> return p->pi_top_task;
>}
>extern void rt_mutex_setprio(struct task_struct *p, struct task_struct *pi_task);
>extern void rt_mutex_adjust_pi(struct task_struct *p);
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/rt.h"
>extern void normalize_rt_tasks(void);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/ioprio.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/iocontext.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/iocontext.h"
>enum {
> ICQ_EXITED = 1 << 2,
> ICQ_DESTROYED = 1 << 3,
>};
># 73 "/usr/src/linux-5.14.21-150500.53/include/linux/iocontext.h"
>struct io_cq {
> struct request_queue *q;
> struct io_context *ioc;
>
>
>
>
>
>
>
> union {
>  struct list_head q_node;
>  struct kmem_cache *__rcu_icq_cache;
> };
> union {
>  struct hlist_node ioc_node;
>  struct callback_head __rcu_head;
> };
>
> unsigned int flags;
>};
>
>
>
>
>
>struct io_context {
> atomic_long_t refcount;
> atomic_t active_ref;
>
> unsigned short ioprio;
>
>
>
> spinlock_t lock;
>
> struct xarray icq_tree;
> struct io_cq *icq_hint;
> struct hlist_head icq_list;
>
> struct work_struct release_work;
>
>};
>
>struct task_struct;
>
>void put_io_context(struct io_context *ioc);
>void exit_io_context(struct task_struct *task);
>int __copy_io(unsigned long clone_flags, struct task_struct *tsk);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int copy_io(unsigned long clone_flags, struct task_struct *tsk)
>{
> if (!get_current()->io_context)
>  return 0;
> return __copy_io(clone_flags, tsk);
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/ioprio.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ioprio.h" 1
># 27 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ioprio.h"
>enum {
> IOPRIO_CLASS_NONE,
> IOPRIO_CLASS_RT,
> IOPRIO_CLASS_BE,
> IOPRIO_CLASS_IDLE,
>};
>
>
>
>
>
>
>
>enum {
> IOPRIO_WHO_PROCESS = 1,
> IOPRIO_WHO_PGRP,
> IOPRIO_WHO_USER,
>};
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/ioprio.h" 2
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/ioprio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ioprio_valid(unsigned short ioprio)
>{
> unsigned short class = (((ioprio) >> 13) & 0x07);
>
> return class > IOPRIO_CLASS_NONE && class <= IOPRIO_CLASS_IDLE;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int task_nice_ioprio(struct task_struct *task)
>{
> return (task_nice(task) + 20) / 5;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int task_nice_ioclass(struct task_struct *task)
>{
> if (task->policy == 5)
>  return IOPRIO_CLASS_IDLE;
> else if (task_is_realtime(task))
>  return IOPRIO_CLASS_RT;
> else
>  return IOPRIO_CLASS_BE;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_current_ioprio(void)
>{
> struct io_context *ioc = get_current()->io_context;
>
> if (ioc)
>  return ioc->ioprio;
> return ((((IOPRIO_CLASS_BE) & 0x07) << 13) | ((4) & ((1UL << 13) - 1)));
>}
>
>
>
>
>extern int ioprio_best(unsigned short aprio, unsigned short bprio);
>
>extern int set_task_ioprio(struct task_struct *task, int ioprio);
>
>
>extern int ioprio_check_cap(int ioprio);
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fs_types.h" 1
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/fs_types.h"
>extern unsigned char fs_ftype_to_dtype(unsigned int filetype);
>extern unsigned char fs_umode_to_ftype(umode_t mode);
>extern unsigned char fs_umode_to_dtype(umode_t mode);
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mount.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/mount.h"
>struct super_block;
>struct vfsmount;
>struct dentry;
>struct mnt_namespace;
>struct fs_context;
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/mount.h"
>struct vfsmount {
> struct dentry *mnt_root;
> struct super_block *mnt_sb;
> int mnt_flags;
> struct user_namespace *mnt_userns;
> void *suse_kabi_padding;
>} __attribute__((__designated_init__));
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct user_namespace *mnt_user_ns(const struct vfsmount *mnt)
>{
>
> return ({ typeof(*&mnt->mnt_userns) ___p1 = ({ do { extern void __compiletime_assert_236(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&mnt->mnt_userns) == sizeof(char) || sizeof(*&mnt->mnt_userns) == sizeof(short) || sizeof(*&mnt->mnt_userns) == sizeof(int) || sizeof(*&mnt->mnt_userns) == sizeof(long)) || sizeof(*&mnt->mnt_userns) == sizeof(long long))) __compiletime_assert_236(); } while (0); (*(const volatile typeof( _Generic((*&mnt->mnt_userns), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&mnt->mnt_userns))) *)&(*&mnt->mnt_userns)); }); do { extern void __compiletime_assert_237(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&mnt->mnt_userns) == sizeof(char) || sizeof(*&mnt->mnt_userns) == sizeof(short) || sizeof(*&mnt->mnt_userns) == sizeof(int) || sizeof(*&mnt->mnt_userns) == sizeof(long)))) __compiletime_assert_237(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
>}
>
>struct file;
>struct path;
>
>extern int mnt_want_write(struct vfsmount *mnt);
>extern int mnt_want_write_file(struct file *file);
>extern void mnt_drop_write(struct vfsmount *mnt);
>extern void mnt_drop_write_file(struct file *file);
>extern void mntput(struct vfsmount *mnt);
>extern struct vfsmount *mntget(struct vfsmount *mnt);
>extern struct vfsmount *mnt_clone_internal(const struct path *path);
>extern bool __mnt_is_readonly(struct vfsmount *mnt);
>extern bool mnt_may_suid(struct vfsmount *mnt);
>
>struct path;
>extern struct vfsmount *clone_private_mount(const struct path *path);
>extern int __mnt_want_write(struct vfsmount *);
>extern void __mnt_drop_write(struct vfsmount *);
>
>struct file_system_type;
>extern struct vfsmount *fc_mount(struct fs_context *fc);
>extern struct vfsmount *vfs_create_mount(struct fs_context *fc);
>extern struct vfsmount *vfs_kern_mount(struct file_system_type *type,
>          int flags, const char *name,
>          void *data);
>extern struct vfsmount *vfs_submount(const struct dentry *mountpoint,
>         struct file_system_type *type,
>         const char *name, void *data);
>
>extern void mnt_set_expiry(struct vfsmount *mnt, struct list_head *expiry_list);
>extern void mark_mounts_for_expiry(struct list_head *mounts);
>
>extern dev_t name_to_dev_t(const char *name);
>
>extern unsigned int sysctl_mount_max;
>
>extern bool path_is_mountpoint(const struct path *path);
>
>extern void kern_unmount_array(struct vfsmount *mnt[], unsigned int num);
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fs.h" 1
># 54 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fs.h"
>struct file_clone_range {
> __s64 src_fd;
> __u64 src_offset;
> __u64 src_length;
> __u64 dest_offset;
>};
>
>struct fstrim_range {
> __u64 start;
> __u64 len;
> __u64 minlen;
>};
>
>
>
>
>
>
>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 files_stat_struct {
> unsigned long nr_files;
> unsigned long nr_free_files;
> unsigned long max_files;
>};
>
>struct inodes_stat_t {
> long nr_inodes;
> long nr_unused;
> long dummy[5];
>};
>
>
>
>
>
>
>
>struct fsxattr {
> __u32 fsx_xflags;
> __u32 fsx_extsize;
> __u32 fsx_nextents;
> __u32 fsx_projid;
> __u32 fsx_cowextsize;
> unsigned char fsx_pad[8];
>};
># 287 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fs.h"
>typedef int __kernel_rwf_t;
># 47 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
>
>struct backing_dev_info;
>struct bdi_writeback;
>struct bio;
>struct io_comp_batch;
>struct export_operations;
>struct fiemap_extent_info;
>struct hd_geometry;
>struct iovec;
>struct kiocb;
>struct kobject;
>struct pipe_inode_info;
>struct poll_table_struct;
>struct kstatfs;
>struct vm_area_struct;
>struct vfsmount;
>struct cred;
>struct swap_info_struct;
>struct seq_file;
>struct workqueue_struct;
>struct iov_iter;
>struct fscrypt_info;
>struct fscrypt_operations;
>struct fsverity_info;
>struct fsverity_operations;
>struct fs_context;
>struct fs_parameter_spec;
>struct fileattr;
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) inode_init(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) inode_init_early(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) files_init(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) files_maxfiles_init(void);
>
>extern struct files_stat_struct files_stat;
>extern unsigned long get_max_files(void);
>extern unsigned int sysctl_nr_open;
>extern struct inodes_stat_t inodes_stat;
>extern int leases_enable, lease_break_time;
>extern int sysctl_protected_symlinks;
>extern int sysctl_protected_hardlinks;
>extern int sysctl_protected_fifos;
>extern int sysctl_protected_regular;
>
>typedef __kernel_rwf_t rwf_t;
>
>struct buffer_head;
>typedef int (get_block_t)(struct inode *inode, sector_t iblock,
>   struct buffer_head *bh_result, int create);
>typedef int (dio_iodone_t)(struct kiocb *iocb, loff_t offset,
>   ssize_t bytes, void *private);
># 223 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct iattr {
> unsigned int ia_valid;
> umode_t ia_mode;
> kuid_t ia_uid;
> kgid_t ia_gid;
> loff_t ia_size;
> struct timespec64 ia_atime;
> struct timespec64 ia_mtime;
> struct timespec64 ia_ctime;
>
>
>
>
>
>
> struct file *ia_file;
>};
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h" 1
># 42 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/dqblk_xfs.h" 1
># 53 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/dqblk_xfs.h"
>typedef struct fs_disk_quota {
> __s8 d_version;
> __s8 d_flags;
> __u16 d_fieldmask;
> __u32 d_id;
> __u64 d_blk_hardlimit;
> __u64 d_blk_softlimit;
> __u64 d_ino_hardlimit;
> __u64 d_ino_softlimit;
> __u64 d_bcount;
> __u64 d_icount;
> __s32 d_itimer;
>
>
> __s32 d_btimer;
> __u16 d_iwarns;
> __u16 d_bwarns;
> __s8 d_itimer_hi;
> __s8 d_btimer_hi;
> __s8 d_rtbtimer_hi;
> __s8 d_padding2;
> __u64 d_rtb_hardlimit;
> __u64 d_rtb_softlimit;
> __u64 d_rtbcount;
> __s32 d_rtbtimer;
> __u16 d_rtbwarns;
> __s16 d_padding3;
> char d_padding4[8];
>} fs_disk_quota_t;
># 159 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/dqblk_xfs.h"
>typedef struct fs_qfilestat {
> __u64 qfs_ino;
> __u64 qfs_nblks;
> __u32 qfs_nextents;
>} fs_qfilestat_t;
>
>typedef 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;
>} fs_quota_stat_t;
># 202 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/dqblk_xfs.h"
>struct fs_qfilestatv {
> __u64 qfs_ino;
> __u64 qfs_nblks;
> __u32 qfs_nextents;
> __u32 qfs_pad;
>};
>
>struct fs_quota_statv {
> __s8 qs_version;
> __u8 qs_pad1;
> __u16 qs_flags;
> __u32 qs_incoredqs;
> struct fs_qfilestatv qs_uquota;
> struct fs_qfilestatv qs_gquota;
> struct fs_qfilestatv qs_pquota;
> __s32 qs_btimelimit;
> __s32 qs_itimelimit;
> __s32 qs_rtbtimelimit;
> __u16 qs_bwarnlimit;
> __u16 qs_iwarnlimit;
> __u16 qs_rtbwarnlimit;
> __u16 qs_pad3;
> __u32 qs_pad4;
> __u64 qs_pad2[7];
>};
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dqblk_v1.h" 1
># 44 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dqblk_v2.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/dqblk_v2.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dqblk_qtree.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/dqblk_qtree.h"
>struct dquot;
>struct kqid;
>
>
>struct qtree_fmt_operations {
> void (*mem2disk_dqblk)(void *disk, struct dquot *dquot);
> void (*disk2mem_dqblk)(struct dquot *dquot, void *disk);
> int (*is_id)(void *disk, struct dquot *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;
>};
>
>int qtree_write_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
>int qtree_read_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
>int qtree_delete_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
>int qtree_release_dquot(struct qtree_mem_dqinfo *info, struct dquot *dquot);
>int qtree_entry_unused(struct qtree_mem_dqinfo *info, char *disk);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int qtree_depth(struct qtree_mem_dqinfo *info)
>{
> unsigned int epb = info->dqi_usable_bs >> 2;
> unsigned long long entries = epb;
> int i;
>
> for (i = 1; entries < (1ULL << 32); i++)
>  entries *= epb;
> return i;
>}
>int qtree_get_next_id(struct qtree_mem_dqinfo *info, struct kqid *qid);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/dqblk_v2.h" 2
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/projid.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/projid.h"
>struct user_namespace;
>extern struct user_namespace init_user_ns;
>
>typedef __kernel_uid32_t projid_t;
>
>typedef struct {
> projid_t val;
>} kprojid_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) projid_t __kprojid_val(kprojid_t projid)
>{
> return projid.val;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool projid_eq(kprojid_t left, kprojid_t right)
>{
> return __kprojid_val(left) == __kprojid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool projid_lt(kprojid_t left, kprojid_t right)
>{
> return __kprojid_val(left) < __kprojid_val(right);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool projid_valid(kprojid_t projid)
>{
> return !projid_eq(projid, (kprojid_t){ -1 });
>}
>
>
>
>extern kprojid_t make_kprojid(struct user_namespace *from, projid_t projid);
>
>extern projid_t from_kprojid(struct user_namespace *to, kprojid_t projid);
>extern projid_t from_kprojid_munged(struct user_namespace *to, kprojid_t projid);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kprojid_has_mapping(struct user_namespace *ns, kprojid_t projid)
>{
> return from_kprojid(ns, projid) != (projid_t)-1;
>}
># 49 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/quota.h" 1
># 90 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/quota.h"
>enum {
> QIF_BLIMITS_B = 0,
> QIF_SPACE_B,
> QIF_ILIMITS_B,
> QIF_INODES_B,
> QIF_BTIME_B,
> QIF_ITIME_B,
>};
># 110 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/quota.h"
>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_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;
>};
># 144 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/quota.h"
>enum {
> DQF_ROOT_SQUASH_B = 0,
> DQF_SYS_FILE_B = 16,
>
> DQF_PRIVATE
>};
>
>
>
>
>
>
>struct if_dqinfo {
> __u64 dqi_bgrace;
> __u64 dqi_igrace;
> __u32 dqi_flags;
> __u32 dqi_valid;
>};
># 178 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/quota.h"
>enum {
> QUOTA_NL_C_UNSPEC,
> QUOTA_NL_C_WARNING,
> __QUOTA_NL_C_MAX,
>};
>
>
>enum {
> QUOTA_NL_A_UNSPEC,
> QUOTA_NL_A_QTYPE,
> QUOTA_NL_A_EXCESS_ID,
> QUOTA_NL_A_WARNING,
> QUOTA_NL_A_DEV_MAJOR,
> QUOTA_NL_A_DEV_MINOR,
> QUOTA_NL_A_CAUSED_ID,
> QUOTA_NL_A_PAD,
> __QUOTA_NL_A_MAX,
>};
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h" 2
>
>
>
>
>enum quota_type {
> USRQUOTA = 0,
> GRPQUOTA = 1,
> PRJQUOTA = 2,
>};
>
>
>
>
>
>
>typedef __kernel_uid32_t qid_t;
>typedef long long qsize_t;
>
>struct kqid {
> union {
>  kuid_t uid;
>  kgid_t gid;
>  kprojid_t projid;
> };
> enum quota_type type;
>};
>
>extern bool qid_eq(struct kqid left, struct kqid right);
>extern bool qid_lt(struct kqid left, struct kqid right);
>extern qid_t from_kqid(struct user_namespace *to, struct kqid qid);
>extern qid_t from_kqid_munged(struct user_namespace *to, struct kqid qid);
>extern bool qid_valid(struct kqid qid);
># 97 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kqid make_kqid(struct user_namespace *from,
>        enum quota_type type, qid_t qid)
>{
> struct kqid kqid;
>
> kqid.type = type;
> switch (type) {
> case USRQUOTA:
>  kqid.uid = make_kuid(from, qid);
>  break;
> case GRPQUOTA:
>  kqid.gid = make_kgid(from, qid);
>  break;
> case PRJQUOTA:
>  kqid.projid = make_kprojid(from, qid);
>  break;
> default:
>  do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"), "i" (114), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("238" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "238" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0);
> }
> return kqid;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kqid make_kqid_invalid(enum quota_type type)
>{
> struct kqid kqid;
>
> kqid.type = type;
> switch (type) {
> case USRQUOTA:
>  kqid.uid = (kuid_t){ -1 };
>  break;
> case GRPQUOTA:
>  kqid.gid = (kgid_t){ -1 };
>  break;
> case PRJQUOTA:
>  kqid.projid = (kprojid_t){ -1 };
>  break;
> default:
>  do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"), "i" (141), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("239" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "239" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0);
> }
> return kqid;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kqid make_kqid_uid(kuid_t uid)
>{
> struct kqid kqid;
> kqid.type = USRQUOTA;
> kqid.uid = uid;
> return kqid;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kqid make_kqid_gid(kgid_t gid)
>{
> struct kqid kqid;
> kqid.type = GRPQUOTA;
> kqid.gid = gid;
> return kqid;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kqid make_kqid_projid(kprojid_t projid)
>{
> struct kqid kqid;
> kqid.type = PRJQUOTA;
> kqid.projid = projid;
> return kqid;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool qid_has_mapping(struct user_namespace *ns, struct kqid qid)
>{
> return from_kqid(ns, qid) != (qid_t) -1;
>}
>
>
>extern spinlock_t dq_data_lock;
># 205 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>struct mem_dqblk {
> qsize_t dqb_bhardlimit;
> qsize_t dqb_bsoftlimit;
> qsize_t dqb_curspace;
> qsize_t dqb_rsvspace;
> qsize_t dqb_ihardlimit;
> qsize_t dqb_isoftlimit;
> qsize_t dqb_curinodes;
> time64_t dqb_btime;
> time64_t dqb_itime;
>};
>
>
>
>
>struct quota_format_type;
>
>struct mem_dqinfo {
> struct quota_format_type *dqi_format;
> int dqi_fmt_id;
>
> struct list_head dqi_dirty_list;
> unsigned long 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 super_block;
>
>
>
>
>
>
>enum {
> DQF_INFO_DIRTY_B = DQF_PRIVATE,
>};
>
>
>extern void mark_info_dirty(struct super_block *sb, int type);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int info_dirty(struct mem_dqinfo *info)
>{
> return test_bit(DQF_INFO_DIRTY_B, &info->dqi_flags);
>}
>
>enum {
> DQST_LOOKUPS,
> DQST_DROPS,
> DQST_READS,
> DQST_WRITES,
> DQST_CACHE_HITS,
> DQST_ALLOC_DQUOTS,
> DQST_FREE_DQUOTS,
> DQST_SYNCS,
> _DQST_DQSTAT_LAST
>};
>
>struct dqstats {
> unsigned long stat[_DQST_DQSTAT_LAST];
> struct percpu_counter counter[_DQST_DQSTAT_LAST];
>};
>
>extern struct dqstats dqstats;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dqstats_inc(unsigned int type)
>{
> percpu_counter_inc(&dqstats.counter[type]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dqstats_dec(unsigned int type)
>{
> percpu_counter_dec(&dqstats.counter[type]);
>}
># 294 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>struct dquot {
> struct hlist_node dq_hash;
> struct list_head dq_inuse;
> struct list_head dq_free;
> struct list_head dq_dirty;
> struct mutex dq_lock;
> spinlock_t dq_dqb_lock;
> atomic_t dq_count;
> struct super_block *dq_sb;
> struct kqid dq_id;
> loff_t dq_off;
> unsigned long dq_flags;
> struct mem_dqblk dq_dqb;
>};
>
>
>struct quota_format_ops {
> int (*check_quota_file)(struct super_block *sb, int type);
> int (*read_file_info)(struct super_block *sb, int type);
> int (*write_file_info)(struct super_block *sb, int type);
> int (*free_file_info)(struct super_block *sb, int type);
> int (*read_dqblk)(struct dquot *dquot);
> int (*commit_dqblk)(struct dquot *dquot);
> int (*release_dqblk)(struct dquot *dquot);
> int (*get_next_id)(struct super_block *sb, struct kqid *qid);
>};
>
>
>struct dquot_operations {
> int (*write_dquot) (struct dquot *);
> struct dquot *(*alloc_dquot)(struct super_block *, int);
> void (*destroy_dquot)(struct dquot *);
> int (*acquire_dquot) (struct dquot *);
> int (*release_dquot) (struct dquot *);
> int (*mark_dirty) (struct dquot *);
> int (*write_info) (struct super_block *, int);
>
>
> qsize_t *(*get_reserved_space) (struct inode *);
> int (*get_projid) (struct inode *, kprojid_t *);
>
> int (*get_inode_usage) (struct inode *, qsize_t *);
>
> int (*get_next_id) (struct super_block *sb, struct kqid *qid);
>};
>
>struct path;
>
>
>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;
>};
># 395 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>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;
> unsigned long long ino;
> blkcnt_t blocks;
> blkcnt_t nextents;
>};
>
>struct qc_state {
> unsigned int s_incoredqs;
> struct qc_type_state s_state[3];
>};
>
>
>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 quotactl_ops {
> int (*quota_on)(struct super_block *, int, int, const struct path *);
> int (*quota_off)(struct super_block *, int);
> int (*quota_enable)(struct super_block *, unsigned int);
> int (*quota_disable)(struct super_block *, unsigned int);
> int (*quota_sync)(struct super_block *, int);
> int (*set_info)(struct super_block *, int, struct qc_info *);
> int (*get_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
> int (*get_nextdqblk)(struct super_block *, struct kqid *,
>        struct qc_dqblk *);
> int (*set_dqblk)(struct super_block *, struct kqid, struct qc_dqblk *);
> int (*get_state)(struct super_block *, struct qc_state *);
> int (*rm_xquota)(struct super_block *, unsigned int);
>};
>
>struct quota_format_type {
> int qf_fmt_id;
> const struct quota_format_ops *qf_ops;
> struct module *qf_owner;
> struct quota_format_type *qf_next;
>};
># 464 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>enum {
> _DQUOT_USAGE_ENABLED = 0,
> _DQUOT_LIMITS_ENABLED,
> _DQUOT_SUSPENDED,
>
>
> _DQUOT_STATE_FLAGS
>};
># 491 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int dquot_state_flag(unsigned int flags, int type)
>{
> return flags << type;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int dquot_generic_flag(unsigned int flags, int type)
>{
> return (flags >> type) & ((1 << _DQUOT_USAGE_ENABLED * 3) | (1 << _DQUOT_LIMITS_ENABLED * 3) | (1 << _DQUOT_SUSPENDED * 3));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned dquot_state_types(unsigned flags, unsigned flag)
>{
> do { extern void __compiletime_assert_240(void) __attribute__((__error__("BUILD_BUG_ON failed: " "(flag) == 0 || (((flag) & ((flag) - 1)) != 0)"))); if (!(!((flag) == 0 || (((flag) & ((flag) - 1)) != 0)))) __compiletime_assert_240(); } while (0);
> return (flags / flag) & ((1 << 3) - 1);
>}
>
>
>extern void quota_send_warning(struct kqid qid, dev_t dev,
>          const char warntype);
># 519 "/usr/src/linux-5.14.21-150500.53/include/linux/quota.h"
>struct quota_info {
> unsigned int flags;
> struct rw_semaphore dqio_sem;
> struct inode *files[3];
> struct mem_dqinfo info[3];
> const struct quota_format_ops *ops[3];
>};
>
>int register_quota_format(struct quota_format_type *fmt);
>void unregister_quota_format(struct quota_format_type *fmt);
>
>struct quota_module_name {
> int qm_fmt_id;
> char *qm_mod_name;
>};
># 245 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 278 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>enum positive_aop_returns {
> AOP_WRITEPAGE_ACTIVATE = 0x80000,
> AOP_TRUNCATED_PAGE = 0x80001,
>};
># 291 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct page;
>struct address_space;
>struct writeback_control;
>struct readahead_control;
>
>
>
>
>
>enum rw_hint {
> WRITE_LIFE_NOT_SET = 0,
> WRITE_LIFE_NONE = 1,
> WRITE_LIFE_SHORT = 2,
> WRITE_LIFE_MEDIUM = 3,
> WRITE_LIFE_LONG = 4,
> WRITE_LIFE_EXTREME = 5,
>};
># 326 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct kiocb {
> struct file *ki_filp;
>
>
>
>
> loff_t ki_pos;
> void (*ki_complete)(struct kiocb *iocb, long ret);
> void *private;
> int ki_flags;
> u16 ki_hint;
> u16 ki_ioprio;
> struct wait_page_queue *ki_waitq;
>
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_sync_kiocb(struct kiocb *kiocb)
>{
> return kiocb->ki_complete == ((void *)0);
>}
># 356 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>typedef struct {
> size_t written;
> size_t count;
> union {
>  char *buf;
>  void *data;
> } arg;
> int error;
>} read_descriptor_t;
>
>typedef int (*read_actor_t)(read_descriptor_t *, struct page *,
>  unsigned long, unsigned long);
>
>struct address_space_operations {
> int (*writepage)(struct page *page, struct writeback_control *wbc);
> int (*readpage)(struct file *, struct page *);
>
>
> int (*writepages)(struct address_space *, struct writeback_control *);
>
>
> int (*set_page_dirty)(struct page *page);
>
>
>
>
>
> int (*readpages)(struct file *filp, struct address_space *mapping,
>   struct list_head *pages, unsigned nr_pages);
> void (*readahead)(struct readahead_control *);
>
> int (*write_begin)(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned flags,
>    struct page **pagep, void **fsdata);
> int (*write_end)(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned copied,
>    struct page *page, void *fsdata);
>
>
> sector_t (*bmap)(struct address_space *, 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 *, struct iov_iter *iter);
>
>
>
>
> int (*migratepage) (struct address_space *,
>   struct page *, struct page *, enum migrate_mode);
> bool (*isolate_page)(struct page *, isolate_mode_t);
> void (*putback_page)(struct page *);
> int (*launder_page) (struct page *);
> int (*is_partially_uptodate) (struct page *, unsigned long,
>     unsigned long);
> void (*is_dirty_writeback) (struct page *, bool *, bool *);
> int (*error_remove_page)(struct address_space *, struct page *);
>
>
> int (*swap_activate)(struct swap_info_struct *sis, struct file *file,
>    sector_t *span);
> void (*swap_deactivate)(struct file *file);
>};
>
>extern const struct address_space_operations empty_aops;
>
>
>
>
>
>int pagecache_write_begin(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned flags,
>    struct page **pagep, void **fsdata);
>
>int pagecache_write_end(struct file *, struct address_space *mapping,
>    loff_t pos, unsigned len, unsigned copied,
>    struct page *page, void *fsdata);
># 456 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct address_space {
> struct inode *host;
> struct xarray i_pages;
> struct rw_semaphore invalidate_lock;
> gfp_t gfp_mask;
> atomic_t i_mmap_writable;
>
>
> atomic_t nr_thps;
>
> struct rb_root_cached i_mmap;
> struct rw_semaphore i_mmap_rwsem;
> unsigned long nrpages;
> unsigned long writeback_index;
> const struct address_space_operations *a_ops;
> unsigned long flags;
> errseq_t wb_err;
> spinlock_t private_lock;
> struct list_head private_list;
> void *private_data;
>} __attribute__((aligned(sizeof(long)))) __attribute__((__designated_init__));
># 491 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mapping_tagged(struct address_space *mapping, xa_mark_t tag)
>{
> return xa_marked(&mapping->i_pages, tag);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_mmap_lock_write(struct address_space *mapping)
>{
> down_write(&mapping->i_mmap_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i_mmap_trylock_write(struct address_space *mapping)
>{
> return down_write_trylock(&mapping->i_mmap_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_mmap_unlock_write(struct address_space *mapping)
>{
> up_write(&mapping->i_mmap_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_mmap_lock_read(struct address_space *mapping)
>{
> down_read(&mapping->i_mmap_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_mmap_unlock_read(struct address_space *mapping)
>{
> up_read(&mapping->i_mmap_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_mmap_assert_locked(struct address_space *mapping)
>{
> do { (void)(&mapping->i_mmap_rwsem); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_mmap_assert_write_locked(struct address_space *mapping)
>{
> do { (void)(&mapping->i_mmap_rwsem); } while (0);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mapping_mapped(struct address_space *mapping)
>{
> return !(({ do { extern void __compiletime_assert_241(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((&mapping->i_mmap.rb_root)->rb_node) == sizeof(char) || sizeof((&mapping->i_mmap.rb_root)->rb_node) == sizeof(short) || sizeof((&mapping->i_mmap.rb_root)->rb_node) == sizeof(int) || sizeof((&mapping->i_mmap.rb_root)->rb_node) == sizeof(long)) || sizeof((&mapping->i_mmap.rb_root)->rb_node) == sizeof(long long))) __compiletime_assert_241(); } while (0); (*(const volatile typeof( _Generic(((&mapping->i_mmap.rb_root)->rb_node), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((&mapping->i_mmap.rb_root)->rb_node))) *)&((&mapping->i_mmap.rb_root)->rb_node)); }) == ((void *)0));
>}
># 548 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mapping_writably_mapped(struct address_space *mapping)
>{
> return atomic_read(&mapping->i_mmap_writable) > 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mapping_map_writable(struct address_space *mapping)
>{
> return atomic_inc_unless_negative(&mapping->i_mmap_writable) ?
>  0 : -1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_unmap_writable(struct address_space *mapping)
>{
> atomic_dec(&mapping->i_mmap_writable);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mapping_deny_writable(struct address_space *mapping)
>{
> return atomic_dec_unless_positive(&mapping->i_mmap_writable) ?
>  0 : -16;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_allow_writable(struct address_space *mapping)
>{
> atomic_inc(&mapping->i_mmap_writable);
>}
># 586 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct posix_acl;
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct posix_acl *
>uncached_acl_sentinel(struct task_struct *task)
>{
> return (void *)task + 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>is_uncached_acl(struct posix_acl *acl)
>{
> return (long)acl & 1;
>}
>
>
>
>
>
>
>
>struct fsnotify_mark_connector;
>
>
>
>
>
>
>struct inode {
> umode_t i_mode;
> unsigned short i_opflags;
> kuid_t i_uid;
> kgid_t i_gid;
> unsigned int i_flags;
>
>
> struct posix_acl *i_acl;
> struct posix_acl *i_default_acl;
>
>
> const struct inode_operations *i_op;
> struct super_block *i_sb;
> struct address_space *i_mapping;
>
>
> void *i_security;
>
>
>
> unsigned long i_ino;
>
>
>
>
>
>
>
> union {
>  const unsigned int i_nlink;
>  unsigned int __i_nlink;
> };
> dev_t i_rdev;
> loff_t i_size;
> struct timespec64 i_atime;
> struct timespec64 i_mtime;
> struct timespec64 i_ctime;
> spinlock_t i_lock;
> unsigned short i_bytes;
> u8 i_blkbits;
> u8 i_write_hint;
> blkcnt_t i_blocks;
>
>
>
>
>
>
> unsigned long i_state;
> struct rw_semaphore i_rwsem;
>
> unsigned long dirtied_when;
> unsigned long dirtied_time_when;
>
> struct hlist_node i_hash;
> struct list_head i_io_list;
>
> struct bdi_writeback *i_wb;
>
>
> int i_wb_frn_winner;
> u16 i_wb_frn_avg_time;
> u16 i_wb_frn_history;
>
> struct list_head i_lru;
> struct list_head i_sb_list;
> struct list_head i_wb_list;
> union {
>  struct hlist_head i_dentry;
>  struct callback_head i_rcu;
> };
> atomic64_t i_version;
> atomic64_t i_sequence;
> atomic_t i_count;
> atomic_t i_dio_count;
> atomic_t i_writecount;
>
> atomic_t i_readcount;
>
> union {
>  const struct file_operations *i_fop;
>  void (*free_inode)(struct inode *);
> };
> struct file_lock_context *i_flctx;
> struct address_space i_data;
> struct list_head i_devices;
> union {
>  struct pipe_inode_info *i_pipe;
>  struct cdev *i_cdev;
>  char *i_link;
>  unsigned i_dir_seq;
> };
>
> __u32 i_generation;
>
>
> __u32 i_fsnotify_mask;
> struct fsnotify_mark_connector *i_fsnotify_marks;
>
>
>
> struct fscrypt_info *i_crypt_info;
>
>
>
> struct fsverity_info *i_verity_info;
>
>
> void *i_private;
>} __attribute__((__designated_init__));
>
>struct timespec64 timestamp_truncate(struct timespec64 t, struct inode *inode);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int i_blocksize(const struct inode *node)
>{
> return (1 << node->i_blkbits);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inode_unhashed(struct inode *inode)
>{
> return hlist_unhashed(&inode->i_hash);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_fake_hash(struct inode *inode)
>{
> hlist_add_fake(&inode->i_hash);
>}
># 766 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>enum inode_i_mutex_lock_class
>{
> I_MUTEX_NORMAL,
> I_MUTEX_PARENT,
> I_MUTEX_CHILD,
> I_MUTEX_XATTR,
> I_MUTEX_NONDIR2,
> I_MUTEX_PARENT2,
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_lock(struct inode *inode)
>{
> down_write(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_unlock(struct inode *inode)
>{
> up_write(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_lock_shared(struct inode *inode)
>{
> down_read(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_unlock_shared(struct inode *inode)
>{
> up_read(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inode_trylock(struct inode *inode)
>{
> return down_write_trylock(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inode_trylock_shared(struct inode *inode)
>{
> return down_read_trylock(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inode_is_locked(struct inode *inode)
>{
> return rwsem_is_locked(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_lock_nested(struct inode *inode, unsigned subclass)
>{
> down_write(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_lock_shared_nested(struct inode *inode, unsigned subclass)
>{
> down_read(&inode->i_rwsem);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_invalidate_lock(struct address_space *mapping)
>{
> down_write(&mapping->invalidate_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_invalidate_unlock(struct address_space *mapping)
>{
> up_write(&mapping->invalidate_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_invalidate_lock_shared(struct address_space *mapping)
>{
> down_read(&mapping->invalidate_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int filemap_invalidate_trylock_shared(
>     struct address_space *mapping)
>{
> return down_read_trylock(&mapping->invalidate_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_invalidate_unlock_shared(
>     struct address_space *mapping)
>{
> up_read(&mapping->invalidate_lock);
>}
>
>void lock_two_nondirectories(struct inode *, struct inode*);
>void unlock_two_nondirectories(struct inode *, struct inode*);
>
>void filemap_invalidate_lock_two(struct address_space *mapping1,
>     struct address_space *mapping2);
>void filemap_invalidate_unlock_two(struct address_space *mapping1,
>       struct address_space *mapping2);
># 867 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) loff_t i_size_read(const struct inode *inode)
>{
># 886 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
> return inode->i_size;
>
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_size_write(struct inode *inode, loff_t i_size)
>{
># 908 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
> inode->i_size = i_size;
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned iminor(const struct inode *inode)
>{
> return ((unsigned int) ((inode->i_rdev) & ((1U << 20) - 1)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned imajor(const struct inode *inode)
>{
> return ((unsigned int) ((inode->i_rdev) >> 20));
>}
>
>struct fown_struct {
> rwlock_t lock;
> struct pid *pid;
> enum pid_type pid_type;
> kuid_t uid, euid;
> int signum;
>};
># 939 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct file_ra_state {
> unsigned long start;
> unsigned int size;
> unsigned int async_size;
> unsigned int ra_pages;
> unsigned int mmap_miss;
> loff_t prev_pos;
>};
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ra_has_index(struct file_ra_state *ra, unsigned long index)
>{
> return (index >= ra->start &&
>  index < ra->start + ra->size);
>}
>
>struct file {
> 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 *f_op;
>
>
>
>
>
> spinlock_t f_lock;
> enum rw_hint f_write_hint;
> 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 *f_security;
>
>
> void *private_data;
>
>
>
> struct hlist_head *f_ep;
>
> struct address_space *f_mapping;
> errseq_t f_wb_err;
> errseq_t f_sb_err;
>} __attribute__((__designated_init__))
>  __attribute__((aligned(4)));
>
>struct file_handle {
> __u32 handle_bytes;
> int handle_type;
>
> unsigned char f_handle[];
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct file *get_file(struct file *f)
>{
> atomic_long_inc(&f->f_count);
> return f;
>}
># 1047 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>typedef void *fl_owner_t;
>
>struct file_lock;
>
>struct file_lock_operations {
> void (*fl_copy_lock)(struct file_lock *, struct file_lock *);
> void (*fl_release_private)(struct file_lock *);
>};
>
>struct lock_manager_operations {
> 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 **);
> bool (*lm_breaker_owns_lease)(struct file_lock *);
>};
>
>struct lock_manager {
> struct list_head list;
>
>
>
>
> bool block_opens;
>};
>
>struct net;
>void locks_start_grace(struct net *, struct lock_manager *);
>void locks_end_grace(struct lock_manager *);
>bool locks_in_grace(struct net *);
>bool opens_in_grace(struct net *);
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/nfs_fs_i.h" 1
>
>
>
>
>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;
>};
># 1084 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h" 2
># 1102 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct file_lock {
> struct file_lock *fl_blocker;
> struct list_head fl_list;
> struct hlist_node fl_link;
> struct list_head fl_blocked_requests;
>
>
> struct list_head fl_blocked_member;
>
>
> fl_owner_t fl_owner;
> unsigned int fl_flags;
> unsigned char fl_type;
> unsigned int fl_pid;
> int fl_link_cpu;
> wait_queue_head_t fl_wait;
> struct file *fl_file;
> loff_t fl_start;
> loff_t fl_end;
>
> struct fasync_struct * fl_fasync;
>
> unsigned long fl_break_time;
> unsigned long 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;
>   unsigned int debug_id;
>  } afs;
> } fl_u;
>} __attribute__((__designated_init__));
>
>struct file_lock_context {
> spinlock_t flc_lock;
> struct list_head flc_flock;
> struct list_head flc_posix;
> struct list_head flc_lease;
>};
># 1154 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>extern void send_sigio(struct fown_struct *fown, int fd, int band);
>
>
>
>
>extern int fcntl_getlk(struct file *, unsigned int, struct flock *);
>extern int fcntl_setlk(unsigned int, struct file *, unsigned int,
>   struct flock *);
>
>
>
>
>
>
>
>extern int fcntl_setlease(unsigned int fd, struct file *filp, long arg);
>extern int fcntl_getlease(struct file *filp);
>
>
>void locks_free_lock_context(struct inode *inode);
>void locks_free_lock(struct file_lock *fl);
>extern void locks_init_lock(struct file_lock *);
>extern struct file_lock * locks_alloc_lock(void);
>extern void locks_copy_lock(struct file_lock *, struct file_lock *);
>extern void locks_copy_conflock(struct file_lock *, struct file_lock *);
>extern void locks_remove_posix(struct file *, fl_owner_t);
>extern void locks_remove_file(struct file *);
>extern void locks_release_private(struct file_lock *);
>extern void posix_test_lock(struct file *, struct file_lock *);
>extern int posix_lock_file(struct file *, struct file_lock *, struct file_lock *);
>extern int locks_delete_block(struct file_lock *);
>extern int vfs_test_lock(struct file *, struct file_lock *);
>extern int vfs_lock_file(struct file *, unsigned int, struct file_lock *, struct file_lock *);
>extern int vfs_cancel_lock(struct file *filp, struct file_lock *fl);
>extern int locks_lock_inode_wait(struct inode *inode, struct file_lock *fl);
>extern int __break_lease(struct inode *inode, unsigned int flags, unsigned int type);
>extern void lease_get_mtime(struct inode *, struct timespec64 *time);
>extern int generic_setlease(struct file *, long, struct file_lock **, void **priv);
>extern int vfs_setlease(struct file *, long, struct file_lock **, void **);
>extern int lease_modify(struct file_lock *, int, struct list_head *);
>
>struct notifier_block;
>extern int lease_register_notifier(struct notifier_block *);
>extern void lease_unregister_notifier(struct notifier_block *);
>
>struct files_struct;
>extern void show_fd_locks(struct seq_file *f,
>    struct file *filp, struct files_struct *files);
># 1339 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct inode *file_inode(const struct file *f)
>{
> return f->f_inode;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct dentry *file_dentry(const struct file *file)
>{
> return d_real(file->f_path.dentry, file_inode(file));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int locks_lock_file_wait(struct file *filp, struct file_lock *fl)
>{
> return locks_lock_inode_wait(file_inode(filp), fl);
>}
>
>struct fasync_struct {
> rwlock_t fa_lock;
> int magic;
> int fa_fd;
> struct fasync_struct *fa_next;
> struct file *fa_file;
> struct callback_head fa_rcu;
>};
>
>
>
>
>extern int fasync_helper(int, struct file *, int, struct fasync_struct **);
>extern struct fasync_struct *fasync_insert_entry(int, struct file *, struct fasync_struct **, struct fasync_struct *);
>extern int fasync_remove_entry(struct file *, struct fasync_struct **);
>extern struct fasync_struct *fasync_alloc(void);
>extern void fasync_free(struct fasync_struct *);
>
>
>extern void kill_fasync(struct fasync_struct **, int, int);
>
>extern void __f_setown(struct file *filp, struct pid *, enum pid_type, int force);
>extern int f_setown(struct file *filp, unsigned long arg, int force);
>extern void f_delown(struct file *filp);
>extern pid_t f_getown(struct file *filp);
>extern int send_sigurg(struct fown_struct *fown);
># 1440 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>enum {
> SB_UNFROZEN = 0,
> SB_FREEZE_WRITE = 1,
> SB_FREEZE_PAGEFAULT = 2,
> SB_FREEZE_FS = 3,
>
> SB_FREEZE_COMPLETE = 4,
>};
>
>
>
>struct sb_writers {
> int frozen;
> wait_queue_head_t wait_unfrozen;
> struct percpu_rw_semaphore rw_sem[(SB_FREEZE_COMPLETE - 1)];
>};
>
>struct super_block {
> struct list_head s_list;
> dev_t s_dev;
> unsigned char s_blocksize_bits;
> unsigned long 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;
> unsigned long s_flags;
> unsigned long s_iflags;
> unsigned long s_magic;
> struct dentry *s_root;
> struct rw_semaphore s_umount;
> int s_count;
> atomic_t s_active;
>
> void *s_security;
>
> const struct xattr_handler **s_xattr;
>
> const struct fscrypt_operations *s_cop;
> struct key *s_master_keys;
>
>
> const struct fsverity_operations *s_vop;
>
>
> struct unicode_map *s_encoding;
> __u16 s_encoding_flags;
>
> struct hlist_bl_head s_roots;
> struct list_head s_mounts;
> struct block_device *s_bdev;
> struct backing_dev_info *s_bdi;
> struct mtd_info *s_mtd;
> struct hlist_node s_instances;
> unsigned int s_quota_types;
> struct quota_info s_dquot;
>
> struct sb_writers s_writers;
>
>
>
>
>
>
> void *s_fs_info;
>
>
> u32 s_time_gran;
>
> time64_t s_time_min;
> time64_t s_time_max;
>
> __u32 s_fsnotify_mask;
> struct fsnotify_mark_connector *s_fsnotify_marks;
>
>
> char s_id[32];
> uuid_t s_uuid;
>
> unsigned int s_max_links;
> fmode_t s_mode;
>
>
>
>
>
> struct mutex s_vfs_rename_mutex;
>
>
>
>
>
> const char *s_subtype;
>
> const struct dentry_operations *s_d_op;
>
>
>
>
> int cleancache_poolid;
>
> struct shrinker s_shrink;
>
>
> atomic_long_t s_remove_count;
>
>
>
>
>
> atomic_long_t s_fsnotify_connectors;
>
>
> int s_readonly_remount;
>
>
> errseq_t s_wb_err;
>
>
> struct workqueue_struct *s_dio_done_wq;
> struct hlist_head s_pins;
>
>
>
>
>
>
> struct user_namespace *s_user_ns;
>
>
>
>
>
>
> struct list_lru s_dentry_lru;
> struct list_lru s_inode_lru;
> struct callback_head rcu;
> struct work_struct destroy_work;
>
> struct mutex s_sync_lock;
>
>
>
>
> int s_stack_depth;
>
>
> spinlock_t s_inode_list_lock __attribute__((__aligned__((1 << (6)))));
> struct list_head s_inodes;
>
> spinlock_t s_inode_wblist_lock;
> struct list_head s_inodes_wb;
>} __attribute__((__designated_init__));
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) uid_t i_uid_read(const struct inode *inode)
>{
> return from_kuid(inode->i_sb->s_user_ns, inode->i_uid);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) gid_t i_gid_read(const struct inode *inode)
>{
> return from_kgid(inode->i_sb->s_user_ns, inode->i_gid);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_uid_write(struct inode *inode, uid_t uid)
>{
> inode->i_uid = make_kuid(inode->i_sb->s_user_ns, uid);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_gid_write(struct inode *inode, gid_t gid)
>{
> inode->i_gid = make_kgid(inode->i_sb->s_user_ns, gid);
>}
># 1629 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kuid_t kuid_into_mnt(struct user_namespace *mnt_userns,
>       kuid_t kuid)
>{
> return make_kuid(mnt_userns, __kuid_val(kuid));
>}
># 1643 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kgid_t kgid_into_mnt(struct user_namespace *mnt_userns,
>       kgid_t kgid)
>{
> return make_kgid(mnt_userns, __kgid_val(kgid));
>}
># 1657 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kuid_t i_uid_into_mnt(struct user_namespace *mnt_userns,
>        const struct inode *inode)
>{
> return kuid_into_mnt(mnt_userns, inode->i_uid);
>}
># 1671 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kgid_t i_gid_into_mnt(struct user_namespace *mnt_userns,
>        const struct inode *inode)
>{
> return kgid_into_mnt(mnt_userns, inode->i_gid);
>}
># 1685 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kuid_t kuid_from_mnt(struct user_namespace *mnt_userns,
>       kuid_t kuid)
>{
> return (kuid_t){ from_kuid(mnt_userns, kuid) };
>}
># 1699 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kgid_t kgid_from_mnt(struct user_namespace *mnt_userns,
>       kgid_t kgid)
>{
> return (kgid_t){ from_kgid(mnt_userns, kgid) };
>}
># 1717 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kuid_t mapped_fsuid(struct user_namespace *mnt_userns)
>{
> return kuid_from_mnt(mnt_userns, (({ ({ do { } while (0 && (!((1)))); ; ((typeof(*(get_current()->cred)) *)((get_current()->cred))); })->fsuid; })));
>}
># 1734 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kgid_t mapped_fsgid(struct user_namespace *mnt_userns)
>{
> return kgid_from_mnt(mnt_userns, (({ ({ do { } while (0 && (!((1)))); ; ((typeof(*(get_current()->cred)) *)((get_current()->cred))); })->fsgid; })));
>}
># 1747 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_fsuid_set(struct inode *inode,
>       struct user_namespace *mnt_userns)
>{
> inode->i_uid = mapped_fsuid(mnt_userns);
>}
># 1761 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_fsgid_set(struct inode *inode,
>       struct user_namespace *mnt_userns)
>{
> inode->i_gid = mapped_fsgid(mnt_userns);
>}
># 1778 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fsuidgid_has_mapping(struct super_block *sb,
>     struct user_namespace *mnt_userns)
>{
> struct user_namespace *s_user_ns = sb->s_user_ns;
>
> return kuid_has_mapping(s_user_ns, mapped_fsuid(mnt_userns)) &&
>        kgid_has_mapping(s_user_ns, mapped_fsgid(mnt_userns));
>}
>
>extern struct timespec64 current_time(struct inode *inode);
># 1797 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __sb_end_write(struct super_block *sb, int level)
>{
> percpu_up_read(sb->s_writers.rw_sem + level-1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __sb_start_write(struct super_block *sb, int level)
>{
> percpu_down_read(sb->s_writers.rw_sem + level - 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __sb_start_write_trylock(struct super_block *sb, int level)
>{
> return percpu_down_read_trylock(sb->s_writers.rw_sem + level - 1);
>}
># 1824 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sb_end_write(struct super_block *sb)
>{
> __sb_end_write(sb, SB_FREEZE_WRITE);
>}
># 1836 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sb_end_pagefault(struct super_block *sb)
>{
> __sb_end_write(sb, SB_FREEZE_PAGEFAULT);
>}
># 1848 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sb_end_intwrite(struct super_block *sb)
>{
> __sb_end_write(sb, SB_FREEZE_FS);
>}
># 1872 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sb_start_write(struct super_block *sb)
>{
> __sb_start_write(sb, SB_FREEZE_WRITE);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool sb_start_write_trylock(struct super_block *sb)
>{
> return __sb_start_write_trylock(sb, SB_FREEZE_WRITE);
>}
># 1901 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sb_start_pagefault(struct super_block *sb)
>{
> __sb_start_write(sb, SB_FREEZE_PAGEFAULT);
>}
># 1919 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sb_start_intwrite(struct super_block *sb)
>{
> __sb_start_write(sb, SB_FREEZE_FS);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool sb_start_intwrite_trylock(struct super_block *sb)
>{
> return __sb_start_write_trylock(sb, SB_FREEZE_FS);
>}
>
>bool inode_owner_or_capable(struct user_namespace *mnt_userns,
>       const struct inode *inode);
>
>
>
>
>int vfs_create(struct user_namespace *, struct inode *,
>        struct dentry *, umode_t, bool);
>int vfs_mkdir(struct user_namespace *, struct inode *,
>       struct dentry *, umode_t);
>int vfs_mknod(struct user_namespace *, struct inode *, struct dentry *,
>              umode_t, dev_t);
>int vfs_symlink(struct user_namespace *, struct inode *,
>  struct dentry *, const char *);
>int vfs_link(struct dentry *, struct user_namespace *, struct inode *,
>      struct dentry *, struct inode **);
>int vfs_rmdir(struct user_namespace *, struct inode *, struct dentry *);
>int vfs_unlink(struct user_namespace *, struct inode *, struct dentry *,
>        struct inode **);
># 1960 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct renamedata {
> struct user_namespace *old_mnt_userns;
> struct inode *old_dir;
> struct dentry *old_dentry;
> struct user_namespace *new_mnt_userns;
> struct inode *new_dir;
> struct dentry *new_dentry;
> struct inode **delegated_inode;
> unsigned int flags;
>} __attribute__((__designated_init__));
>
>int vfs_rename(struct renamedata *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vfs_whiteout(struct user_namespace *mnt_userns,
>          struct inode *dir, struct dentry *dentry)
>{
> return vfs_mknod(mnt_userns, dir, dentry, 0020000 | 0,
>    0);
>}
>
>struct dentry *vfs_tmpfile(struct user_namespace *mnt_userns,
>      struct dentry *dentry, umode_t mode, int open_flag);
>
>int vfs_mkobj(struct dentry *, umode_t,
>  int (*f)(struct dentry *, umode_t, void *),
>  void *);
>
>int vfs_fchown(struct file *file, uid_t user, gid_t group);
>int vfs_fchmod(struct file *file, umode_t mode);
>int vfs_utimes(const struct path *path, struct timespec64 *times);
>
>extern long vfs_ioctl(struct file *file, unsigned int cmd, unsigned long arg);
>
>
>extern long compat_ptr_ioctl(struct file *file, unsigned int cmd,
>     unsigned long arg);
>
>
>
>
>
>
>
>void inode_init_owner(struct user_namespace *mnt_userns, struct inode *inode,
>        const struct inode *dir, umode_t mode);
>extern bool may_open_dev(const struct path *path);
>umode_t mode_strip_sgid(struct user_namespace *mnt_userns,
>   const struct inode *dir, umode_t mode);
>
>
>
>
>
>
>
>struct dir_context;
>typedef int (*filldir_t)(struct dir_context *, const char *, int, loff_t, u64,
>    unsigned);
>
>struct dir_context {
> filldir_t actor;
> loff_t pos;
>};
># 2063 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct iov_iter;
>struct io_uring_cmd;
>
>struct file_operations {
> struct module *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 *, struct iov_iter *);
> ssize_t (*write_iter) (struct kiocb *, struct iov_iter *);
> int (*iopoll)(struct kiocb *kiocb, struct io_comp_batch *,
>   unsigned int flags);
> int (*iterate) (struct file *, struct dir_context *);
> int (*iterate_shared) (struct file *, struct dir_context *);
> __poll_t (*poll) (struct file *, struct poll_table_struct *);
> long (*unlocked_ioctl) (struct file *, unsigned int, unsigned long);
> long (*compat_ioctl) (struct file *, unsigned int, unsigned long);
> int (*mmap) (struct file *, struct vm_area_struct *);
> unsigned long mmap_supported_flags;
> int (*open) (struct inode *, struct file *);
> int (*flush) (struct file *, fl_owner_t id);
> int (*release) (struct inode *, struct file *);
> int (*fsync) (struct file *, loff_t, loff_t, int datasync);
> int (*fasync) (int, struct file *, int);
> int (*lock) (struct file *, int, struct file_lock *);
> ssize_t (*sendpage) (struct file *, struct page *, int, size_t, loff_t *, int);
> unsigned long (*get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
> int (*check_flags)(int);
> int (*flock) (struct file *, int, struct file_lock *);
> ssize_t (*splice_write)(struct pipe_inode_info *, struct file *, loff_t *, size_t, unsigned int);
> ssize_t (*splice_read)(struct file *, loff_t *, struct pipe_inode_info *, size_t, unsigned int);
> int (*setlease)(struct file *, long, struct file_lock **, void **);
> long (*fallocate)(struct file *file, int mode, loff_t offset,
>     loff_t len);
> void (*show_fdinfo)(struct seq_file *m, struct file *f);
>
>
>
> ssize_t (*copy_file_range)(struct file *, loff_t, struct file *,
>   loff_t, size_t, unsigned int);
> loff_t (*remap_file_range)(struct file *file_in, loff_t pos_in,
>       struct file *file_out, loff_t pos_out,
>       loff_t len, unsigned int remap_flags);
> int (*fadvise)(struct file *, loff_t, loff_t, int);
> int (*uring_cmd)(struct io_uring_cmd *ioucmd, unsigned int issue_flags);
>} __attribute__((__designated_init__));
>
>struct inode_operations {
> struct dentry * (*lookup) (struct inode *,struct dentry *, unsigned int);
> const char * (*get_link) (struct dentry *, struct inode *, struct delayed_call *);
> int (*permission) (struct user_namespace *, struct inode *, int);
> struct posix_acl * (*get_acl)(struct inode *, int);
>
> int (*readlink) (struct dentry *, char *,int);
>
> int (*create) (struct user_namespace *, struct inode *,struct dentry *,
>         umode_t, bool);
> int (*link) (struct dentry *,struct inode *,struct dentry *);
> int (*unlink) (struct inode *,struct dentry *);
> int (*symlink) (struct user_namespace *, struct inode *,struct dentry *,
>   const char *);
> int (*mkdir) (struct user_namespace *, struct inode *,struct dentry *,
>        umode_t);
> int (*rmdir) (struct inode *,struct dentry *);
> int (*mknod) (struct user_namespace *, struct inode *,struct dentry *,
>        umode_t,dev_t);
> int (*rename) (struct user_namespace *, struct inode *, struct dentry *,
>   struct inode *, struct dentry *, unsigned int);
> int (*setattr) (struct user_namespace *, struct dentry *,
>   struct iattr *);
> int (*getattr) (struct user_namespace *, const struct path *,
>   struct kstat *, u32, unsigned int);
> ssize_t (*listxattr) (struct dentry *, char *, size_t);
> int (*fiemap)(struct inode *, struct fiemap_extent_info *, u64 start,
>        u64 len);
> int (*update_time)(struct inode *, struct timespec64 *, int);
> int (*atomic_open)(struct inode *, struct dentry *,
>      struct file *, unsigned open_flag,
>      umode_t create_mode);
> int (*tmpfile) (struct user_namespace *, struct inode *,
>   struct dentry *, umode_t);
> int (*set_acl)(struct user_namespace *, struct inode *,
>         struct posix_acl *, int);
> int (*fileattr_set)(struct user_namespace *mnt_userns,
>       struct dentry *dentry, struct fileattr *fa);
> int (*fileattr_get)(struct dentry *dentry, struct fileattr *fa);
>} __attribute__((__aligned__((1 << (6)))));
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t call_read_iter(struct file *file, struct kiocb *kio,
>         struct iov_iter *iter)
>{
> return file->f_op->read_iter(kio, iter);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t call_write_iter(struct file *file, struct kiocb *kio,
>          struct iov_iter *iter)
>{
> return file->f_op->write_iter(kio, iter);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int call_mmap(struct file *file, struct vm_area_struct *vma)
>{
> return file->f_op->mmap(file, vma);
>}
>
>extern ssize_t vfs_read(struct file *, char *, size_t, loff_t *);
>extern ssize_t vfs_write(struct file *, const char *, size_t, loff_t *);
>extern ssize_t vfs_copy_file_range(struct file *, loff_t , struct file *,
>       loff_t, size_t, unsigned int);
>extern ssize_t generic_copy_file_range(struct file *file_in, loff_t pos_in,
>           struct file *file_out, loff_t pos_out,
>           size_t len, unsigned int flags);
>extern int generic_remap_file_range_prep(struct file *file_in, loff_t pos_in,
>      struct file *file_out, loff_t pos_out,
>      loff_t *count,
>      unsigned int remap_flags);
>extern loff_t do_clone_file_range(struct file *file_in, loff_t pos_in,
>      struct file *file_out, loff_t pos_out,
>      loff_t len, unsigned int remap_flags);
>extern loff_t vfs_clone_file_range(struct file *file_in, loff_t pos_in,
>       struct file *file_out, loff_t pos_out,
>       loff_t len, unsigned int remap_flags);
>extern int vfs_dedupe_file_range(struct file *file,
>     struct file_dedupe_range *same);
>extern loff_t vfs_dedupe_file_range_one(struct file *src_file, loff_t src_pos,
>     struct file *dst_file, loff_t dst_pos,
>     loff_t len, unsigned int remap_flags);
>
>
>struct super_operations {
>    struct inode *(*alloc_inode)(struct super_block *sb);
> void (*destroy_inode)(struct inode *);
> void (*free_inode)(struct inode *);
>
>    void (*dirty_inode) (struct inode *, int flags);
> int (*write_inode) (struct inode *, struct writeback_control *wbc);
> int (*drop_inode) (struct inode *);
> void (*evict_inode) (struct inode *);
> void (*put_super) (struct super_block *);
> int (*sync_fs)(struct super_block *sb, int wait);
> 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 *, struct kstatfs *);
> int (*remount_fs) (struct super_block *, int *, char *);
> void (*umount_begin) (struct super_block *);
>
> int (*show_options)(struct seq_file *, struct dentry *);
> int (*show_devname)(struct seq_file *, struct dentry *);
> int (*show_path)(struct seq_file *, struct dentry *);
> int (*show_stats)(struct seq_file *, struct dentry *);
>
> ssize_t (*quota_read)(struct super_block *, int, char *, size_t, loff_t);
> ssize_t (*quota_write)(struct super_block *, int, const char *, size_t, loff_t);
> struct dquot **(*get_dquots)(struct inode *);
>
> long (*nr_cached_objects)(struct super_block *,
>      struct shrink_control *);
> long (*free_cached_objects)(struct super_block *,
>        struct shrink_control *);
> dev_t (*get_inode_dev)(const struct inode *);
>};
># 2268 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool sb_rdonly(const struct super_block *sb) { return sb->s_flags & 1; }
># 2298 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool HAS_UNMAPPED_ID(struct user_namespace *mnt_userns,
>       struct inode *inode)
>{
> return !uid_valid(i_uid_into_mnt(mnt_userns, inode)) ||
>        !gid_valid(i_gid_into_mnt(mnt_userns, inode));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) enum rw_hint file_write_hint(struct file *file)
>{
> if (file->f_write_hint != WRITE_LIFE_NOT_SET)
>  return file->f_write_hint;
>
> return file_inode(file)->i_write_hint;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int iocb_flags(struct file *file);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 ki_hint_validate(enum rw_hint hint)
>{
> typeof(((struct kiocb *)0)->ki_hint) max_hint = -1;
>
> if (hint <= max_hint)
>  return hint;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_sync_kiocb(struct kiocb *kiocb, struct file *filp)
>{
> *kiocb = (struct kiocb) {
>  .ki_filp = filp,
>  .ki_flags = iocb_flags(filp),
>  .ki_hint = ki_hint_validate(file_write_hint(filp)),
>  .ki_ioprio = get_current_ioprio(),
> };
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kiocb_clone(struct kiocb *kiocb, struct kiocb *kiocb_src,
>          struct file *filp)
>{
> *kiocb = (struct kiocb) {
>  .ki_filp = filp,
>  .ki_flags = kiocb_src->ki_flags,
>  .ki_hint = kiocb_src->ki_hint,
>  .ki_ioprio = kiocb_src->ki_ioprio,
>  .ki_pos = kiocb_src->ki_pos,
> };
>}
># 2451 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>extern void __mark_inode_dirty(struct inode *, int);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mark_inode_dirty(struct inode *inode)
>{
> __mark_inode_dirty(inode, (((1 << 0) | (1 << 1)) | (1 << 2)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mark_inode_dirty_sync(struct inode *inode)
>{
> __mark_inode_dirty(inode, (1 << 0));
>}
># 2471 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool inode_is_dirtytime_only(struct inode *inode)
>{
> return (inode->i_state & ((1 << 11) | (1 << 3) |
>      (1 << 5) | (1 << 4))) == (1 << 11);
>}
>
>extern void inc_nlink(struct inode *inode);
>extern void drop_nlink(struct inode *inode);
>extern void clear_nlink(struct inode *inode);
>extern void set_nlink(struct inode *inode, unsigned int nlink);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_inc_link_count(struct inode *inode)
>{
> inc_nlink(inode);
> mark_inode_dirty(inode);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_dec_link_count(struct inode *inode)
>{
> drop_nlink(inode);
> mark_inode_dirty(inode);
>}
>
>enum file_time_flags {
> S_ATIME = 1,
> S_MTIME = 2,
> S_CTIME = 4,
> S_VERSION = 8,
>};
>
>extern bool atime_needs_update(const struct path *, struct inode *);
>extern void touch_atime(const struct path *);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void file_accessed(struct file *file)
>{
> if (!(file->f_flags & 01000000))
>  touch_atime(&file->f_path);
>}
>
>extern int file_modified(struct file *file);
>
>int sync_inode(struct inode *inode, struct writeback_control *wbc);
>int sync_inode_metadata(struct inode *inode, int wait);
>
>struct file_system_type {
> const char *name;
> int fs_flags;
># 2525 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
> int (*init_fs_context)(struct fs_context *);
> const struct fs_parameter_spec *parameters;
> struct dentry *(*mount) (struct file_system_type *, int,
>         const char *, void *);
> void (*kill_sb) (struct super_block *);
> struct module *owner;
> struct file_system_type * next;
> struct hlist_head fs_supers;
>
> struct lock_class_key s_lock_key;
> struct lock_class_key s_umount_key;
> struct lock_class_key s_vfs_rename_key;
> struct lock_class_key s_writers_key[(SB_FREEZE_COMPLETE - 1)];
>
> struct lock_class_key i_lock_key;
> struct lock_class_key i_mutex_key;
> struct lock_class_key invalidate_lock_key;
> struct lock_class_key i_mutex_dir_key;
>};
>
>
>
>extern struct dentry *mount_bdev(struct file_system_type *fs_type,
> int flags, const char *dev_name, void *data,
> int (*fill_super)(struct super_block *, void *, int));
>extern struct dentry *mount_single(struct file_system_type *fs_type,
> int flags, void *data,
> int (*fill_super)(struct super_block *, void *, int));
>extern struct dentry *mount_nodev(struct file_system_type *fs_type,
> int flags, void *data,
> int (*fill_super)(struct super_block *, void *, int));
>extern struct dentry *mount_subtree(struct vfsmount *mnt, const char *path);
>void generic_shutdown_super(struct super_block *sb);
>void kill_block_super(struct super_block *sb);
>void kill_anon_super(struct super_block *sb);
>void kill_litter_super(struct super_block *sb);
>void deactivate_super(struct super_block *sb);
>void deactivate_locked_super(struct super_block *sb);
>int set_anon_super(struct super_block *s, void *data);
>int set_anon_super_fc(struct super_block *s, struct fs_context *fc);
>int get_anon_bdev(dev_t *);
>void free_anon_bdev(dev_t);
>struct super_block *sget_fc(struct fs_context *fc,
>       int (*test)(struct super_block *, struct fs_context *),
>       int (*set)(struct super_block *, struct fs_context *));
>struct super_block *sget(struct file_system_type *type,
>   int (*test)(struct super_block *,void *),
>   int (*set)(struct super_block *,void *),
>   int flags, void *data);
># 2592 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>extern int register_filesystem(struct file_system_type *);
>extern int unregister_filesystem(struct file_system_type *);
>extern struct vfsmount *kern_mount(struct file_system_type *);
>extern void kern_unmount(struct vfsmount *mnt);
>extern int may_umount_tree(struct vfsmount *);
>extern int may_umount(struct vfsmount *);
>extern long do_mount(const char *, const char *,
>       const char *, unsigned long, void *);
>extern struct vfsmount *collect_mounts(const struct path *);
>extern void drop_collected_mounts(struct vfsmount *);
>extern int iterate_mounts(int (*)(struct vfsmount *, void *), void *,
>     struct vfsmount *);
>extern int vfs_statfs(const struct path *, struct kstatfs *);
>extern int user_statfs(const char *, struct kstatfs *);
>extern int fd_statfs(int, struct kstatfs *);
>extern int freeze_super(struct super_block *super);
>extern int thaw_super(struct super_block *super);
>extern bool our_mnt(struct vfsmount *mnt);
>extern __attribute__((__format__(printf, 2, 3)))
>int super_setup_bdi_name(struct super_block *sb, char *fmt, ...);
>extern int super_setup_bdi(struct super_block *sb);
>
>extern int current_umask(void);
>
>extern void ihold(struct inode * inode);
>extern void iput(struct inode *);
>extern int generic_update_time(struct inode *, struct timespec64 *, int);
>
>
>extern struct kobject *fs_kobj;
># 2674 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int locks_mandatory_locked(struct file *file)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int locks_mandatory_area(struct inode *inode, struct file *filp,
>                                       loff_t start, loff_t end, unsigned char type)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __mandatory_lock(struct inode *inode)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mandatory_lock(struct inode *inode)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int locks_verify_locked(struct file *file)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int locks_verify_truncate(struct inode *inode, struct file *filp,
>     size_t size)
>{
> return 0;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int break_lease(struct inode *inode, unsigned int mode)
>{
>
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
>  return __break_lease(inode, mode, 32);
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int break_deleg(struct inode *inode, unsigned int mode)
>{
>
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
>  return __break_lease(inode, mode, 4);
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int try_break_deleg(struct inode *inode, struct inode **delegated_inode)
>{
> int ret;
>
> ret = break_deleg(inode, 00000001|00004000);
> if (ret == -11 && delegated_inode) {
>  *delegated_inode = inode;
>  ihold(inode);
> }
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int break_deleg_wait(struct inode **delegated_inode)
>{
> int ret;
>
> ret = break_deleg(*delegated_inode, 00000001);
> iput(*delegated_inode);
> *delegated_inode = ((void *)0);
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int break_layout(struct inode *inode, bool wait)
>{
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> if (inode->i_flctx && !list_empty_careful(&inode->i_flctx->flc_lease))
>  return __break_lease(inode,
>    wait ? 00000001 : 00000001 | 00004000,
>    2048);
> return 0;
>}
># 2800 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>struct audit_names;
>struct filename {
> const char *name;
> const char *uptr;
> int refcnt;
> struct audit_names *aname;
> const char iname[];
>};
>_Static_assert(__builtin_offsetof(struct filename, iname) % sizeof(long) == 0, "offsetof(struct filename, iname) % sizeof(long) == 0");
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct user_namespace *file_mnt_user_ns(struct file *file)
>{
> return mnt_user_ns(file->f_path.mnt);
>}
># 2823 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_idmapped_mnt(const struct vfsmount *mnt)
>{
> return mnt_user_ns(mnt) != &init_user_ns;
>}
>
>extern long vfs_truncate(const struct path *, loff_t);
>int do_truncate(struct user_namespace *, struct dentry *, loff_t start,
>  unsigned int time_attrs, struct file *filp);
>extern int vfs_fallocate(struct file *file, int mode, loff_t offset,
>   loff_t len);
>extern long do_sys_open(int dfd, const char *filename, int flags,
>   umode_t mode);
>extern struct file *file_open_name(struct filename *, int, umode_t);
>extern struct file *filp_open(const char *, int, umode_t);
>extern struct file *file_open_root(const struct path *,
>       const char *, int, umode_t);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct file *file_open_root_mnt(struct vfsmount *mnt,
>       const char *name, int flags, umode_t mode)
>{
> return file_open_root(&(struct path){.mnt = mnt, .dentry = mnt->mnt_root},
>         name, flags, mode);
>}
>extern struct file * dentry_open(const struct path *, int, const struct cred *);
>extern struct file * open_with_fake_path(const struct path *, int,
>      struct inode*, const struct cred *);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct file *file_clone_open(struct file *file)
>{
> return dentry_open(&file->f_path, file->f_flags, file->f_cred);
>}
>extern int filp_close(struct file *, fl_owner_t id);
>
>extern struct filename *getname_flags(const char *, int, int *);
>extern struct filename *getname_uflags(const char *, int);
>extern struct filename *getname(const char *);
>extern struct filename *getname_kernel(const char *);
>extern void putname(struct filename *name);
>
>extern int finish_open(struct file *file, struct dentry *dentry,
>   int (*open)(struct inode *, struct file *));
>extern int finish_no_open(struct file *file, struct dentry *dentry);
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) vfs_caches_init_early(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) vfs_caches_init(void);
>
>extern struct kmem_cache *names_cachep;
>
>
>
>
>extern struct super_block *blockdev_superblock;
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool sb_is_blkdev_sb(struct super_block *sb)
>{
> return 1 && sb == blockdev_superblock;
>}
>
>void emergency_thaw_all(void);
>extern int sync_filesystem(struct super_block *);
>extern const struct file_operations def_blk_fops;
>extern const struct file_operations def_chr_fops;
># 2892 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>extern int alloc_chrdev_region(dev_t *, unsigned, unsigned, const char *);
>extern int register_chrdev_region(dev_t, unsigned, const char *);
>extern int __register_chrdev(unsigned int major, unsigned int baseminor,
>        unsigned int count, const char *name,
>        const struct file_operations *fops);
>extern void __unregister_chrdev(unsigned int major, unsigned int baseminor,
>    unsigned int count, const char *name);
>extern void unregister_chrdev_region(dev_t, unsigned);
>extern void chrdev_show(struct seq_file *,off_t);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int register_chrdev(unsigned int major, const char *name,
>      const struct file_operations *fops)
>{
> return __register_chrdev(major, 0, 256, name, fops);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unregister_chrdev(unsigned int major, const char *name)
>{
> __unregister_chrdev(major, 0, 256, name);
>}
>
>extern void init_special_inode(struct inode *, umode_t, dev_t);
>
>
>extern void make_bad_inode(struct inode *);
>extern bool is_bad_inode(struct inode *);
>
>unsigned long invalidate_mapping_pages(struct address_space *mapping,
>     unsigned long start, unsigned long end);
>
>void invalidate_mapping_pagevec(struct address_space *mapping,
>    unsigned long start, unsigned long end,
>    unsigned long *nr_pagevec);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void invalidate_remote_inode(struct inode *inode)
>{
> if ((((inode->i_mode) & 00170000) == 0100000) || (((inode->i_mode) & 00170000) == 0040000) ||
>     (((inode->i_mode) & 00170000) == 0120000))
>  invalidate_mapping_pages(inode->i_mapping, 0, -1);
>}
>extern int invalidate_inode_pages2(struct address_space *mapping);
>extern int invalidate_inode_pages2_range(struct address_space *mapping,
>      unsigned long start, unsigned long end);
>extern int write_inode_now(struct inode *, int);
>extern int filemap_fdatawrite(struct address_space *);
>extern int filemap_flush(struct address_space *);
>extern int filemap_fdatawait_keep_errors(struct address_space *mapping);
>extern int filemap_fdatawait_range(struct address_space *, loff_t lstart,
>       loff_t lend);
>extern int filemap_fdatawait_range_keep_errors(struct address_space *mapping,
>  loff_t start_byte, loff_t end_byte);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int filemap_fdatawait(struct address_space *mapping)
>{
> return filemap_fdatawait_range(mapping, 0, ((long long)(~0ULL >> 1)));
>}
>
>extern bool filemap_range_has_page(struct address_space *, loff_t lstart,
>      loff_t lend);
>extern int filemap_write_and_wait_range(struct address_space *mapping,
>            loff_t lstart, loff_t lend);
>extern int __filemap_fdatawrite_range(struct address_space *mapping,
>    loff_t start, loff_t end, int sync_mode);
>extern int filemap_fdatawrite_range(struct address_space *mapping,
>    loff_t start, loff_t end);
>extern int filemap_check_errors(struct address_space *mapping);
>extern void __filemap_set_wb_err(struct address_space *mapping, int err);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int filemap_write_and_wait(struct address_space *mapping)
>{
> return filemap_write_and_wait_range(mapping, 0, ((long long)(~0ULL >> 1)));
>}
>
>extern int __attribute__((__warn_unused_result__)) file_fdatawait_range(struct file *file, loff_t lstart,
>      loff_t lend);
>extern int __attribute__((__warn_unused_result__)) file_check_and_advance_wb_err(struct file *file);
>extern int __attribute__((__warn_unused_result__)) file_write_and_wait_range(struct file *file,
>      loff_t start, loff_t end);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int file_write_and_wait(struct file *file)
>{
> return file_write_and_wait_range(file, 0, ((long long)(~0ULL >> 1)));
>}
># 2990 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_set_wb_err(struct address_space *mapping, int err)
>{
>
> if (__builtin_expect(!!(err), 0))
>  __filemap_set_wb_err(mapping, err);
>}
># 3007 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int filemap_check_wb_err(struct address_space *mapping,
>     errseq_t since)
>{
> return errseq_check(&mapping->wb_err, since);
>}
># 3020 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) errseq_t filemap_sample_wb_err(struct address_space *mapping)
>{
> return errseq_sample(&mapping->wb_err);
>}
># 3032 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) errseq_t file_sample_sb_err(struct file *file)
>{
> return errseq_sample(&file->f_path.dentry->d_sb->s_wb_err);
>}
>
>extern int vfs_fsync_range(struct file *file, loff_t start, loff_t end,
>      int datasync);
>extern int vfs_fsync(struct file *file, int datasync);
>
>extern int sync_file_range(struct file *file, loff_t offset, loff_t nbytes,
>    unsigned int flags);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t generic_write_sync(struct kiocb *iocb, ssize_t count)
>{
> if (iocb->ki_flags & ( int) (( __kernel_rwf_t)0x00000002)) {
>  int ret = vfs_fsync_range(iocb->ki_filp,
>    iocb->ki_pos - count, iocb->ki_pos - 1,
>    (iocb->ki_flags & ( int) (( __kernel_rwf_t)0x00000004)) ? 0 : 1);
>  if (ret)
>   return ret;
> }
>
> return count;
>}
>
>extern void emergency_sync(void);
>extern void emergency_remount(void);
>
>
>extern int bmap(struct inode *inode, sector_t *block);
>
>
>
>
>
>
>
>int notify_change(struct user_namespace *, struct dentry *,
>    struct iattr *, struct inode **);
>int inode_permission(struct user_namespace *, struct inode *, int);
>int generic_permission(struct user_namespace *, struct inode *, int);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int file_permission(struct file *file, int mask)
>{
> return inode_permission(file_mnt_user_ns(file),
>    file_inode(file), mask);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int path_permission(const struct path *path, int mask)
>{
> return inode_permission(mnt_user_ns(path->mnt),
>    d_inode(path->dentry), mask);
>}
>int __check_sticky(struct user_namespace *mnt_userns, struct inode *dir,
>     struct inode *inode);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool execute_ok(struct inode *inode)
>{
> return (inode->i_mode & (00100|00010|00001)) || (((inode->i_mode) & 00170000) == 0040000);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool inode_wrong_type(const struct inode *inode, umode_t mode)
>{
> return (inode->i_mode ^ mode) & 00170000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void file_start_write(struct file *file)
>{
> if (!(((file_inode(file)->i_mode) & 00170000) == 0100000))
>  return;
> sb_start_write(file_inode(file)->i_sb);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool file_start_write_trylock(struct file *file)
>{
> if (!(((file_inode(file)->i_mode) & 00170000) == 0100000))
>  return true;
> return sb_start_write_trylock(file_inode(file)->i_sb);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void file_end_write(struct file *file)
>{
> if (!(((file_inode(file)->i_mode) & 00170000) == 0100000))
>  return;
> __sb_end_write(file_inode(file)->i_sb, SB_FREEZE_WRITE);
>}
># 3138 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_write_access(struct inode *inode)
>{
> return atomic_inc_unless_negative(&inode->i_writecount) ? 0 : -26;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int deny_write_access(struct file *file)
>{
> struct inode *inode = file_inode(file);
> return atomic_dec_unless_positive(&inode->i_writecount) ? 0 : -26;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_write_access(struct inode * inode)
>{
> atomic_dec(&inode->i_writecount);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void allow_write_access(struct file *file)
>{
> if (file)
>  atomic_inc(&file_inode(file)->i_writecount);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool inode_is_open_for_write(const struct inode *inode)
>{
> return atomic_read(&inode->i_writecount) > 0;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_readcount_dec(struct inode *inode)
>{
> do { if (__builtin_expect(!!(!atomic_read(&inode->i_readcount)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"), "i" (3164), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("242" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "242" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> atomic_dec(&inode->i_readcount);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i_readcount_inc(struct inode *inode)
>{
> atomic_inc(&inode->i_readcount);
>}
># 3181 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>extern int do_pipe_flags(int *, int);
>
>extern ssize_t kernel_read(struct file *, void *, size_t, loff_t *);
>ssize_t __kernel_read(struct file *file, void *buf, size_t count, loff_t *pos);
>extern ssize_t kernel_write(struct file *, const void *, size_t, loff_t *);
>extern ssize_t __kernel_write(struct file *, const void *, size_t, loff_t *);
>extern struct file * open_exec(const char *);
>
>
>extern bool is_subdir(struct dentry *, struct dentry *);
>extern bool path_is_under(const struct path *, const struct path *);
>
>extern char *file_path(struct file *, char *, int);
>
>
>
>
>extern loff_t default_llseek(struct file *file, loff_t offset, int whence);
>
>extern loff_t vfs_llseek(struct file *file, loff_t offset, int whence);
>
>extern int inode_init_always(struct super_block *, struct inode *);
>extern void inode_init_once(struct inode *);
>extern void address_space_init_once(struct address_space *mapping);
>extern struct inode * igrab(struct inode *);
>extern ino_t iunique(struct super_block *, ino_t);
>extern int inode_needs_sync(struct inode *inode);
>extern int generic_delete_inode(struct inode *inode);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int generic_drop_inode(struct inode *inode)
>{
> return !inode->i_nlink || inode_unhashed(inode);
>}
>extern void d_mark_dontcache(struct inode *inode);
>
>extern struct inode *ilookup5_nowait(struct super_block *sb,
>  unsigned long hashval, int (*test)(struct inode *, void *),
>  void *data);
>extern struct inode *ilookup5(struct super_block *sb, unsigned long hashval,
>  int (*test)(struct inode *, void *), void *data);
>extern struct inode *ilookup(struct super_block *sb, unsigned long ino);
>
>extern struct inode *inode_insert5(struct inode *inode, unsigned long hashval,
>  int (*test)(struct inode *, void *),
>  int (*set)(struct inode *, void *),
>  void *data);
>extern struct inode * iget5_locked(struct super_block *, unsigned long, int (*test)(struct inode *, void *), int (*set)(struct inode *, void *), void *);
>extern struct inode * iget_locked(struct super_block *, unsigned long);
>extern struct inode *find_inode_nowait(struct super_block *,
>           unsigned long,
>           int (*match)(struct inode *,
>          unsigned long, void *),
>           void *data);
>extern struct inode *find_inode_rcu(struct super_block *, unsigned long,
>        int (*)(struct inode *, void *), void *);
>extern struct inode *find_inode_by_ino_rcu(struct super_block *, unsigned long);
>extern int insert_inode_locked4(struct inode *, unsigned long, int (*test)(struct inode *, void *), void *);
>extern int insert_inode_locked(struct inode *);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lockdep_annotate_inode_mutex_key(struct inode *inode) { };
>
>extern void unlock_new_inode(struct inode *);
>extern void discard_new_inode(struct inode *);
>extern unsigned int get_next_ino(void);
>extern void evict_inodes(struct super_block *sb);
># 3258 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_zero_ino(ino_t ino)
>{
> return (u32)ino == 0;
>}
>
>extern void __iget(struct inode * inode);
>extern void iget_failed(struct inode *);
>extern void clear_inode(struct inode *);
>extern void __destroy_inode(struct inode *);
>extern struct inode *new_inode_pseudo(struct super_block *sb);
>extern struct inode *new_inode(struct super_block *sb);
>extern void free_inode_nonrcu(struct inode *inode);
>extern int should_remove_suid(struct dentry *);
>extern int file_remove_privs(struct file *);
>
>extern void __insert_inode_hash(struct inode *, unsigned long hashval);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insert_inode_hash(struct inode *inode)
>{
> __insert_inode_hash(inode, inode->i_ino);
>}
>
>extern void __remove_inode_hash(struct inode *);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void remove_inode_hash(struct inode *inode)
>{
> if (!inode_unhashed(inode) && !hlist_fake(&inode->i_hash))
>  __remove_inode_hash(inode);
>}
>
>extern void inode_sb_list_add(struct inode *inode);
>
>extern int sb_set_blocksize(struct super_block *, int);
>extern int sb_min_blocksize(struct super_block *, int);
>
>extern int generic_file_mmap(struct file *, struct vm_area_struct *);
>extern int generic_file_readonly_mmap(struct file *, struct vm_area_struct *);
>extern ssize_t generic_write_checks(struct kiocb *, struct iov_iter *);
>extern int generic_write_check_limits(struct file *file, loff_t pos,
>  loff_t *count);
>extern int generic_file_rw_checks(struct file *file_in, struct file *file_out);
>ssize_t filemap_read(struct kiocb *iocb, struct iov_iter *to,
>  ssize_t already_read);
>extern ssize_t generic_file_read_iter(struct kiocb *, struct iov_iter *);
>extern ssize_t __generic_file_write_iter(struct kiocb *, struct iov_iter *);
>extern ssize_t generic_file_write_iter(struct kiocb *, struct iov_iter *);
>extern ssize_t generic_file_direct_write(struct kiocb *, struct iov_iter *);
>extern ssize_t generic_perform_write(struct file *, struct iov_iter *, loff_t);
>
>ssize_t vfs_iter_read(struct file *file, struct iov_iter *iter, loff_t *ppos,
>  rwf_t flags);
>ssize_t vfs_iter_write(struct file *file, struct iov_iter *iter, loff_t *ppos,
>  rwf_t flags);
>ssize_t vfs_iocb_iter_read(struct file *file, struct kiocb *iocb,
>      struct iov_iter *iter);
>ssize_t vfs_iocb_iter_write(struct file *file, struct kiocb *iocb,
>       struct iov_iter *iter);
>
>
>extern ssize_t generic_file_splice_read(struct file *, loff_t *,
>  struct pipe_inode_info *, size_t, unsigned int);
>extern ssize_t iter_file_splice_write(struct pipe_inode_info *,
>  struct file *, loff_t *, size_t, unsigned int);
>extern ssize_t generic_splice_sendpage(struct pipe_inode_info *pipe,
>  struct file *out, loff_t *, size_t len, unsigned int flags);
>extern long do_splice_direct(struct file *in, loff_t *ppos, struct file *out,
>  loff_t *opos, size_t len, unsigned int flags);
>
>
>extern void
>file_ra_state_init(struct file_ra_state *ra, struct address_space *mapping);
>extern loff_t noop_llseek(struct file *file, loff_t offset, int whence);
>extern loff_t no_llseek(struct file *file, loff_t offset, int whence);
>extern loff_t vfs_setpos(struct file *file, loff_t offset, loff_t maxsize);
>extern loff_t generic_file_llseek(struct file *file, loff_t offset, int whence);
>extern loff_t generic_file_llseek_size(struct file *file, loff_t offset,
>  int whence, loff_t maxsize, loff_t eof);
>extern loff_t fixed_size_llseek(struct file *file, loff_t offset,
>  int whence, loff_t size);
>extern loff_t no_seek_end_llseek_size(struct file *, loff_t, int, loff_t);
>extern loff_t no_seek_end_llseek(struct file *, loff_t, int);
>extern int generic_file_open(struct inode * inode, struct file * filp);
>extern int nonseekable_open(struct inode * inode, struct file * filp);
>extern int stream_open(struct inode * inode, struct file * filp);
>
>
>typedef void (dio_submit_t)(struct bio *bio, struct inode *inode,
>       loff_t file_offset);
>
>enum {
>
> DIO_LOCKING = 0x01,
>
>
> DIO_SKIP_HOLES = 0x02,
>};
>
>ssize_t __blockdev_direct_IO(struct kiocb *iocb, struct inode *inode,
>        struct block_device *bdev, struct iov_iter *iter,
>        get_block_t get_block,
>        dio_iodone_t end_io, dio_submit_t submit_io,
>        int flags);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ssize_t blockdev_direct_IO(struct kiocb *iocb,
>      struct inode *inode,
>      struct iov_iter *iter,
>      get_block_t get_block)
>{
> return __blockdev_direct_IO(iocb, inode, inode->i_sb->s_bdev, iter,
>   get_block, ((void *)0), ((void *)0), DIO_LOCKING | DIO_SKIP_HOLES);
>}
>
>
>void inode_dio_wait(struct inode *inode);
># 3378 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_dio_begin(struct inode *inode)
>{
> atomic_inc(&inode->i_dio_count);
>}
># 3390 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_dio_end(struct inode *inode)
>{
> if (atomic_dec_and_test(&inode->i_dio_count))
>  wake_up_bit(&inode->i_state, 9);
>}
>
>
>
>
>void dio_warn_stale_pagecache(struct file *filp);
>
>extern void inode_set_flags(struct inode *inode, unsigned int flags,
>       unsigned int mask);
>
>extern const struct file_operations generic_ro_fops;
>
>
>
>extern int readlink_copy(char *, int, const char *);
>extern int page_readlink(struct dentry *, char *, int);
>extern const char *page_get_link(struct dentry *, struct inode *,
>     struct delayed_call *);
>extern void page_put_link(void *);
>extern int __page_symlink(struct inode *inode, const char *symname, int len,
>  int nofs);
>extern int page_symlink(struct inode *inode, const char *symname, int len);
>extern const struct inode_operations page_symlink_inode_operations;
>extern void kfree_link(void *);
>void generic_fillattr(struct user_namespace *, struct inode *, struct kstat *);
>extern int vfs_getattr_nosec(const struct path *, struct kstat *, u32, unsigned int);
>extern int vfs_getattr(const struct path *, struct kstat *, u32, unsigned int);
>void __inode_add_bytes(struct inode *inode, loff_t bytes);
>void inode_add_bytes(struct inode *inode, loff_t bytes);
>void __inode_sub_bytes(struct inode *inode, loff_t bytes);
>void inode_sub_bytes(struct inode *inode, loff_t bytes);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) loff_t __inode_get_bytes(struct inode *inode)
>{
> return (((loff_t)inode->i_blocks) << 9) + inode->i_bytes;
>}
>loff_t inode_get_bytes(struct inode *inode);
>void inode_set_bytes(struct inode *inode, loff_t bytes);
>const char *simple_get_link(struct dentry *, struct inode *,
>       struct delayed_call *);
>extern const struct inode_operations simple_symlink_inode_operations;
>
>extern int iterate_dir(struct file *, struct dir_context *);
>
>int vfs_fstatat(int dfd, const char *filename, struct kstat *stat,
>  int flags);
>int vfs_fstat(int fd, struct kstat *stat);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vfs_stat(const char *filename, struct kstat *stat)
>{
> return vfs_fstatat(-100, filename, stat, 0);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vfs_lstat(const char *name, struct kstat *stat)
>{
> return vfs_fstatat(-100, name, stat, 0x100);
>}
>
>extern const char *vfs_get_link(struct dentry *, struct delayed_call *);
>extern int vfs_readlink(struct dentry *, char *, int);
>
>extern struct file_system_type *get_filesystem(struct file_system_type *fs);
>extern void put_filesystem(struct file_system_type *fs);
>extern struct file_system_type *get_fs_type(const char *name);
>extern struct super_block *get_super(struct block_device *);
>extern struct super_block *get_active_super(struct block_device *bdev);
>extern void drop_super(struct super_block *sb);
>extern void drop_super_exclusive(struct super_block *sb);
>extern void iterate_supers(void (*)(struct super_block *, void *), void *);
>extern void iterate_supers_type(struct file_system_type *,
>           void (*)(struct super_block *, void *), void *);
>
>extern int dcache_dir_open(struct inode *, struct file *);
>extern int dcache_dir_close(struct inode *, struct file *);
>extern loff_t dcache_dir_lseek(struct file *, loff_t, int);
>extern int dcache_readdir(struct file *, struct dir_context *);
>extern int simple_setattr(struct user_namespace *, struct dentry *,
>     struct iattr *);
>extern int simple_getattr(struct user_namespace *, const struct path *,
>     struct kstat *, u32, unsigned int);
>extern int simple_statfs(struct dentry *, struct kstatfs *);
>extern int simple_open(struct inode *inode, struct file *file);
>extern int simple_link(struct dentry *, struct inode *, struct dentry *);
>extern int simple_unlink(struct inode *, struct dentry *);
>extern int simple_rmdir(struct inode *, struct dentry *);
>extern int simple_rename_exchange(struct inode *old_dir, struct dentry *old_dentry,
>      struct inode *new_dir, struct dentry *new_dentry);
>extern int simple_rename(struct user_namespace *, struct inode *,
>    struct dentry *, struct inode *, struct dentry *,
>    unsigned int);
>extern void simple_recursive_removal(struct dentry *,
>                              void (*callback)(struct dentry *));
>extern int noop_fsync(struct file *, loff_t, loff_t, int);
>extern void noop_invalidatepage(struct page *page, unsigned int offset,
>  unsigned int length);
>extern ssize_t noop_direct_IO(struct kiocb *iocb, struct iov_iter *iter);
>extern int simple_empty(struct dentry *);
>extern int simple_write_begin(struct file *file, struct address_space *mapping,
>   loff_t pos, unsigned len, unsigned flags,
>   struct page **pagep, void **fsdata);
>extern const struct address_space_operations ram_aops;
>extern int always_delete_dentry(const struct dentry *);
>extern struct inode *alloc_anon_inode(struct super_block *);
>extern int simple_nosetlease(struct file *, long, struct file_lock **, void **);
>extern const struct dentry_operations simple_dentry_operations;
>
>extern struct dentry *simple_lookup(struct inode *, struct dentry *, unsigned int flags);
>extern ssize_t generic_read_dir(struct file *, char *, size_t, loff_t *);
>extern const struct file_operations simple_dir_operations;
>extern const struct inode_operations simple_dir_inode_operations;
>extern void make_empty_dir_inode(struct inode *inode);
>extern bool is_empty_dir_inode(struct inode *inode);
>struct tree_descr { const char *name; const struct file_operations *ops; int mode; };
>struct dentry *d_alloc_name(struct dentry *, const char *);
>extern int simple_fill_super(struct super_block *, unsigned long,
>        const struct tree_descr *);
>extern int simple_pin_fs(struct file_system_type *, struct vfsmount **mount, int *count);
>extern void simple_release_fs(struct vfsmount **mount, int *count);
>
>extern ssize_t simple_read_from_buffer(void *to, size_t count,
>   loff_t *ppos, const void *from, size_t available);
>extern ssize_t simple_write_to_buffer(void *to, size_t available, loff_t *ppos,
>  const void *from, size_t count);
>
>extern int __generic_file_fsync(struct file *, loff_t, loff_t, int);
>extern int generic_file_fsync(struct file *, loff_t, loff_t, int);
>
>extern int generic_check_addressable(unsigned, u64);
>
>extern void generic_set_encrypted_ci_d_ops(struct dentry *dentry);
>
>
>extern int buffer_migrate_page(struct address_space *,
>    struct page *, struct page *,
>    enum migrate_mode);
>extern int buffer_migrate_page_norefs(struct address_space *,
>    struct page *, struct page *,
>    enum migrate_mode);
>
>
>
>
>
>int setattr_prepare(struct user_namespace *, struct dentry *, struct iattr *);
>extern int inode_newsize_ok(const struct inode *, loff_t offset);
>void setattr_copy(struct user_namespace *, struct inode *inode,
>    const struct iattr *attr);
>
>extern int file_update_time(struct file *file);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_dax(const struct vm_area_struct *vma)
>{
> return vma->vm_file && ((vma->vm_file->f_mapping->host)->i_flags & (1 << 13));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_fsdax(struct vm_area_struct *vma)
>{
> struct inode *inode;
>
> if (!1 || !vma->vm_file)
>  return false;
> if (!vma_is_dax(vma))
>  return false;
> inode = file_inode(vma->vm_file);
> if ((((inode->i_mode) & 00170000) == 0020000))
>  return false;
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int iocb_flags(struct file *file)
>{
> int res = 0;
> if (file->f_flags & 00002000)
>  res |= ( int) (( __kernel_rwf_t)0x00000010);
> if (file->f_flags & 00040000)
>  res |= (1 << 17);
> if ((file->f_flags & 00010000) || (((file->f_mapping->host)->i_sb->s_flags & (16)) || ((file->f_mapping->host)->i_flags & (1 << 0))))
>  res |= ( int) (( __kernel_rwf_t)0x00000002);
> if (file->f_flags & 04000000)
>  res |= ( int) (( __kernel_rwf_t)0x00000004);
> return res;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kiocb_set_rw_flags(struct kiocb *ki, rwf_t flags)
>{
> int kiocb_flags = 0;
>
>
> do { extern void __compiletime_assert_243(void) __attribute__((__error__("BUILD_BUG_ON failed: " "(__force int) RWF_SUPPORTED & IOCB_EVENTFD"))); if (!(!(( int) ((( __kernel_rwf_t)0x00000001) | (( __kernel_rwf_t)0x00000002) | (( __kernel_rwf_t)0x00000004) | (( __kernel_rwf_t)0x00000008) | (( __kernel_rwf_t)0x00000010)) & (1 << 16)))) __compiletime_assert_243(); } while (0);
>
> if (!flags)
>  return 0;
> if (__builtin_expect(!!(flags & ~((( __kernel_rwf_t)0x00000001) | (( __kernel_rwf_t)0x00000002) | (( __kernel_rwf_t)0x00000004) | (( __kernel_rwf_t)0x00000008) | (( __kernel_rwf_t)0x00000010))), 0))
>  return -95;
>
> if (flags & (( __kernel_rwf_t)0x00000008)) {
>  if (!(ki->ki_filp->f_mode & (( fmode_t)0x8000000)))
>   return -95;
>  kiocb_flags |= (1 << 20);
> }
> kiocb_flags |= ( int) (flags & ((( __kernel_rwf_t)0x00000001) | (( __kernel_rwf_t)0x00000002) | (( __kernel_rwf_t)0x00000004) | (( __kernel_rwf_t)0x00000008) | (( __kernel_rwf_t)0x00000010)));
> if (flags & (( __kernel_rwf_t)0x00000004))
>  kiocb_flags |= ( int) (( __kernel_rwf_t)0x00000002);
>
> ki->ki_flags |= kiocb_flags;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ino_t parent_ino(struct dentry *dentry)
>{
> ino_t res;
>
>
>
>
>
> spin_lock(&dentry->d_lockref.lock);
> res = dentry->d_parent->d_inode->i_ino;
> spin_unlock(&dentry->d_lockref.lock);
> return res;
>}
>
>
>
>
>
>
>
>struct simple_transaction_argresp {
> ssize_t size;
> char data[];
>};
>
>
>
>char *simple_transaction_get(struct file *file, const char *buf,
>    size_t size);
>ssize_t simple_transaction_read(struct file *file, char *buf,
>    size_t size, loff_t *pos);
>int simple_transaction_release(struct inode *inode, struct file *file);
>
>void simple_transaction_set(struct file *file, size_t n);
># 3666 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__format__(printf, 1, 2)))
>void __simple_attr_check_format(const char *fmt, ...)
>{
>
>}
>
>int simple_attr_open(struct inode *inode, struct file *file,
>       int (*get)(void *, u64 *), int (*set)(void *, u64),
>       const char *fmt);
>int simple_attr_release(struct inode *inode, struct file *file);
>ssize_t simple_attr_read(struct file *file, char *buf,
>    size_t len, loff_t *ppos);
>ssize_t simple_attr_write(struct file *file, const char *buf,
>     size_t len, loff_t *ppos);
>
>struct ctl_table;
>int proc_nr_files(struct ctl_table *table, int write,
>    void *buffer, size_t *lenp, loff_t *ppos);
>int proc_nr_dentry(struct ctl_table *table, int write,
>    void *buffer, size_t *lenp, loff_t *ppos);
>int proc_nr_inodes(struct ctl_table *table, int write,
>     void *buffer, size_t *lenp, loff_t *ppos);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) get_filesystem_list(char *buf);
># 3697 "/usr/src/linux-5.14.21-150500.53/include/linux/fs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_sxid(umode_t mode)
>{
> return (mode & 0004000) || ((mode & 0002000) && (mode & 00010));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int check_sticky(struct user_namespace *mnt_userns,
>          struct inode *dir, struct inode *inode)
>{
> if (!(dir->i_mode & 0001000))
>  return 0;
>
> return __check_sticky(mnt_userns, dir, inode);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_has_no_xattr(struct inode *inode)
>{
> if (!is_sxid(inode->i_mode) && (inode->i_sb->s_flags & (1<<28)))
>  inode->i_flags |= (1 << 12);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_root_inode(struct inode *inode)
>{
> return inode == inode->i_sb->s_root->d_inode;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dir_emit(struct dir_context *ctx,
>       const char *name, int namelen,
>       u64 ino, unsigned type)
>{
> return ctx->actor(ctx, name, namelen, ctx->pos, ino, type) == 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dir_emit_dot(struct file *file, struct dir_context *ctx)
>{
> return ctx->actor(ctx, ".", 1, ctx->pos,
>     file->f_path.dentry->d_inode->i_ino, 4) == 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dir_emit_dotdot(struct file *file, struct dir_context *ctx)
>{
> return ctx->actor(ctx, "..", 2, ctx->pos,
>     parent_ino(file->f_path.dentry), 4) == 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dir_emit_dots(struct file *file, struct dir_context *ctx)
>{
> if (ctx->pos == 0) {
>  if (!dir_emit_dot(file, ctx))
>   return false;
>  ctx->pos = 1;
> }
> if (ctx->pos == 1) {
>  if (!dir_emit_dotdot(file, ctx))
>   return false;
>  ctx->pos = 2;
> }
> return true;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dir_relax(struct inode *inode)
>{
> inode_unlock(inode);
> inode_lock(inode);
> return !((inode)->i_flags & (1 << 4));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dir_relax_shared(struct inode *inode)
>{
> inode_unlock_shared(inode);
> inode_lock_shared(inode);
> return !((inode)->i_flags & (1 << 4));
>}
>
>extern bool path_noexec(const struct path *path);
>extern void inode_nohighmem(struct inode *inode);
>
>
>extern int vfs_fadvise(struct file *file, loff_t offset, loff_t len,
>         int advice);
>extern int generic_fadvise(struct file *file, loff_t offset, loff_t len,
>      int advice);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inode_drain_writes(struct inode *inode)
>{
> inode_dio_wait(inode);
> return filemap_write_and_wait(inode->i_mapping);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dev_t inode_get_dev(const struct inode *inode)
>{
> if (inode->i_sb->s_op->get_inode_dev)
>  return inode->i_sb->s_op->get_inode_dev(inode);
>
> return inode->i_sb->s_dev;
>}
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h" 2
>
>vm_fault_t do_huge_pmd_anonymous_page(struct vm_fault *vmf);
>int copy_huge_pmd(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>    pmd_t *dst_pmd, pmd_t *src_pmd, unsigned long addr,
>    struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma);
>void huge_pmd_set_accessed(struct vm_fault *vmf);
>int copy_huge_pud(struct mm_struct *dst_mm, struct mm_struct *src_mm,
>    pud_t *dst_pud, pud_t *src_pud, unsigned long addr,
>    struct vm_area_struct *vma);
>
>
>void huge_pud_set_accessed(struct vm_fault *vmf, pud_t orig_pud);
>
>
>
>
>
>
>vm_fault_t do_huge_pmd_wp_page(struct vm_fault *vmf);
>struct page *follow_trans_huge_pmd(struct vm_area_struct *vma,
>       unsigned long addr, pmd_t *pmd,
>       unsigned int flags);
>bool madvise_free_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma,
>      pmd_t *pmd, unsigned long addr, unsigned long next);
>int zap_huge_pmd(struct mmu_gather *tlb, struct vm_area_struct *vma, pmd_t *pmd,
>   unsigned long addr);
>int zap_huge_pud(struct mmu_gather *tlb, struct vm_area_struct *vma, pud_t *pud,
>   unsigned long addr);
>bool move_huge_pmd(struct vm_area_struct *vma, unsigned long old_addr,
>     unsigned long new_addr, pmd_t *old_pmd, pmd_t *new_pmd);
>int change_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd, unsigned long addr,
>      pgprot_t newprot, unsigned long cp_flags);
>vm_fault_t vmf_insert_pfn_pmd_prot(struct vm_fault *vmf, pfn_t pfn,
>       pgprot_t pgprot, bool write);
># 55 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) vm_fault_t vmf_insert_pfn_pmd(struct vm_fault *vmf, pfn_t pfn,
>         bool write)
>{
> return vmf_insert_pfn_pmd_prot(vmf, pfn, vmf->vma->vm_page_prot, write);
>}
>vm_fault_t vmf_insert_pfn_pud_prot(struct vm_fault *vmf, pfn_t pfn,
>       pgprot_t pgprot, bool write);
># 74 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) vm_fault_t vmf_insert_pfn_pud(struct vm_fault *vmf, pfn_t pfn,
>         bool write)
>{
> return vmf_insert_pfn_pud_prot(vmf, pfn, vmf->vma->vm_page_prot, write);
>}
>
>enum transparent_hugepage_flag {
> TRANSPARENT_HUGEPAGE_NEVER_DAX,
> TRANSPARENT_HUGEPAGE_FLAG,
> TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG,
> TRANSPARENT_HUGEPAGE_DEFRAG_DIRECT_FLAG,
> TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_FLAG,
> TRANSPARENT_HUGEPAGE_DEFRAG_KSWAPD_OR_MADV_FLAG,
> TRANSPARENT_HUGEPAGE_DEFRAG_REQ_MADV_FLAG,
> TRANSPARENT_HUGEPAGE_DEFRAG_KHUGEPAGED_FLAG,
> TRANSPARENT_HUGEPAGE_USE_ZERO_PAGE_FLAG,
>};
>
>struct kobject;
>struct kobj_attribute;
>
>ssize_t single_hugepage_flag_store(struct kobject *kobj,
>       struct kobj_attribute *attr,
>       const char *buf, size_t count,
>       enum transparent_hugepage_flag flag);
>ssize_t single_hugepage_flag_show(struct kobject *kobj,
>      struct kobj_attribute *attr, char *buf,
>      enum transparent_hugepage_flag flag);
>extern struct kobj_attribute shmem_enabled_attr;
># 116 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h"
>extern unsigned long transparent_hugepage_flags;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool transhuge_vma_suitable(struct vm_area_struct *vma,
>  unsigned long haddr)
>{
>
> if (!vma_is_anonymous(vma)) {
>  if (!((((vma->vm_start >> 12) - vma->vm_pgoff) & ((typeof((vma->vm_start >> 12) - vma->vm_pgoff))((1<<(21 -12))) - 1)) == 0)
>                 )
>   return false;
> }
>
> if (haddr < vma->vm_start || haddr + ((1UL) << 21) > vma->vm_end)
>  return false;
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool transhuge_vma_enabled(struct vm_area_struct *vma,
>       unsigned long vm_flags)
>{
>
> if ((vm_flags & 0x40000000) ||
>     test_bit(24, &vma->vm_mm->flags))
>  return false;
> return true;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __transparent_hugepage_enabled(struct vm_area_struct *vma)
>{
>
>
>
>
> if (transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_NEVER_DAX))
>  return false;
>
> if (!transhuge_vma_enabled(vma, vma->vm_flags))
>  return false;
>
> if (vma_is_temporary_stack(vma))
>  return false;
>
> if (transparent_hugepage_flags & (1 << TRANSPARENT_HUGEPAGE_FLAG))
>  return true;
>
> if (vma_is_dax(vma))
>  return true;
>
> if (transparent_hugepage_flags &
>    (1 << TRANSPARENT_HUGEPAGE_REQ_MADV_FLAG))
>  return !!(vma->vm_flags & 0x20000000);
>
> return false;
>}
>
>bool transparent_hugepage_active(struct vm_area_struct *vma);
>
>
>
>
>
>unsigned long thp_get_unmapped_area(struct file *filp, unsigned long addr,
>  unsigned long len, unsigned long pgoff, unsigned long flags);
>
>void prep_transhuge_page(struct page *page);
>void free_transhuge_page(struct page *page);
>bool is_transparent_hugepage(struct page *page);
>
>bool can_split_huge_page(struct page *page, int *pextra_pins);
>int split_huge_page_to_list(struct page *page, struct list_head *list);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int split_huge_page(struct page *page)
>{
> return split_huge_page_to_list(page, ((void *)0));
>}
>void deferred_split_huge_page(struct page *page);
>
>void __split_huge_pmd(struct vm_area_struct *vma, pmd_t *pmd,
>  unsigned long address, bool freeze, struct page *page);
># 209 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h"
>void split_huge_pmd_address(struct vm_area_struct *vma, unsigned long address,
>  bool freeze, struct page *page);
>
>void __split_huge_pud(struct vm_area_struct *vma, pud_t *pud,
>  unsigned long address);
># 223 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h"
>int hugepage_madvise(struct vm_area_struct *vma, unsigned long *vm_flags,
>       int advice);
>void vma_adjust_trans_huge(struct vm_area_struct *vma, unsigned long start,
>      unsigned long end, long adjust_next);
>spinlock_t *__pmd_trans_huge_lock(pmd_t *pmd, struct vm_area_struct *vma);
>spinlock_t *__pud_trans_huge_lock(pud_t *pud, struct vm_area_struct *vma);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_swap_pmd(pmd_t pmd)
>{
> return !pmd_none(pmd) && !pmd_present(pmd);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pmd_trans_huge_lock(pmd_t *pmd,
>  struct vm_area_struct *vma)
>{
> if (is_swap_pmd(*pmd) || pmd_trans_huge(*pmd) || pmd_devmap(*pmd))
>  return __pmd_trans_huge_lock(pmd, vma);
> else
>  return ((void *)0);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pud_trans_huge_lock(pud_t *pud,
>  struct vm_area_struct *vma)
>{
> if (pud_trans_huge(*pud) || pud_devmap(*pud))
>  return __pud_trans_huge_lock(pud, vma);
> else
>  return ((void *)0);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *thp_head(struct page *page)
>{
> return ((typeof(page))_compound_head(page));
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int thp_order(struct page *page)
>{
> ((void)(sizeof(( long)(PageTail(page)))));
> if (PageHead(page))
>  return (21 -12);
> return 0;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int thp_nr_pages(struct page *page)
>{
> ((void)(sizeof(( long)(PageTail(page)))));
> if (PageHead(page))
>  return (1<<(21 -12));
> return 1;
>}
>
>struct page *follow_devmap_pmd(struct vm_area_struct *vma, unsigned long addr,
>  pmd_t *pmd, int flags, struct dev_pagemap **pgmap);
>struct page *follow_devmap_pud(struct vm_area_struct *vma, unsigned long addr,
>  pud_t *pud, int flags, struct dev_pagemap **pgmap);
>
>vm_fault_t do_huge_pmd_numa_page(struct vm_fault *vmf);
>
>extern struct page *huge_zero_page;
>extern unsigned long huge_zero_pfn;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_huge_zero_page(struct page *page)
>{
> return ({ do { extern void __compiletime_assert_244(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(huge_zero_page) == sizeof(char) || sizeof(huge_zero_page) == sizeof(short) || sizeof(huge_zero_page) == sizeof(int) || sizeof(huge_zero_page) == sizeof(long)) || sizeof(huge_zero_page) == sizeof(long long))) __compiletime_assert_244(); } while (0); (*(const volatile typeof( _Generic((huge_zero_page), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (huge_zero_page))) *)&(huge_zero_page)); }) == page;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_huge_zero_pmd(pmd_t pmd)
>{
> return ({ do { extern void __compiletime_assert_245(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(huge_zero_pfn) == sizeof(char) || sizeof(huge_zero_pfn) == sizeof(short) || sizeof(huge_zero_pfn) == sizeof(int) || sizeof(huge_zero_pfn) == sizeof(long)) || sizeof(huge_zero_pfn) == sizeof(long long))) __compiletime_assert_245(); } while (0); (*(const volatile typeof( _Generic((huge_zero_pfn), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (huge_zero_pfn))) *)&(huge_zero_pfn)); }) == pmd_pfn(pmd) && pmd_present(pmd);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_huge_zero_pud(pud_t pud)
>{
> return false;
>}
>
>struct page *mm_get_huge_zero_page(struct mm_struct *mm);
>void mm_put_huge_zero_page(struct mm_struct *mm);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool thp_migration_supported(void)
>{
> return 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct list_head *page_deferred_list(struct page *page)
>{
>
>
>
>
> return &page[2].deferred_list;
>}
># 493 "/usr/src/linux-5.14.21-150500.53/include/linux/huge_mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long thp_size(struct page *page)
>{
> return ((1UL) << 12) << thp_order(page);
>}
># 725 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
># 742 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int put_page_testzero(struct page *page)
>{
> ((void)(sizeof(( long)(page_ref_count(page) == 0))));
> return page_ref_dec_and_test(page);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int get_page_unless_zero(struct page *page)
>{
> return page_ref_add_unless(page, 1, 0);
>}
>
>extern int page_is_ram(unsigned long pfn);
>
>enum {
> REGION_INTERSECTS,
> REGION_DISJOINT,
> REGION_MIXED,
>};
>
>int region_intersects(resource_size_t offset, size_t size, unsigned long flags,
>        unsigned long desc);
>
>
>struct page *vmalloc_to_page(const void *addr);
>unsigned long vmalloc_to_pfn(const void *addr);
># 786 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern bool is_vmalloc_addr(const void *x);
>extern int is_vmalloc_or_module_addr(const void *x);
># 799 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern void *kvmalloc_node(size_t size, gfp_t flags, int node);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kvmalloc(size_t size, gfp_t flags)
>{
> return kvmalloc_node(size, flags, (-1));
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kvzalloc_node(size_t size, gfp_t flags, int node)
>{
> return kvmalloc_node(size, flags | (( gfp_t)0x100u), node);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kvzalloc(size_t size, gfp_t flags)
>{
> return kvmalloc(size, flags | (( gfp_t)0x100u));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kvmalloc_array(size_t n, size_t size, gfp_t flags)
>{
> size_t bytes;
>
> if (__builtin_expect(!!(__must_check_overflow(({ typeof(n) __a = (n); typeof(size) __b = (size); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_mul_overflow(__a, __b, __d); }))), 0))
>  return ((void *)0);
>
> return kvmalloc(bytes, flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kvcalloc(size_t n, size_t size, gfp_t flags)
>{
> return kvmalloc_array(n, size, flags | (( gfp_t)0x100u));
>}
>
>extern void *kvrealloc(const void *p, size_t oldsize, size_t newsize,
>  gfp_t flags);
>extern void kvfree(const void *addr);
>extern void kvfree_sensitive(const void *addr, size_t len);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int head_compound_mapcount(struct page *head)
>{
> return atomic_read(compound_mapcount_ptr(head)) + 1;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int compound_mapcount(struct page *page)
>{
> ((void)(sizeof(( long)(!PageCompound(page)))));
> page = ((typeof(page))_compound_head(page));
> return head_compound_mapcount(page);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_mapcount_reset(struct page *page)
>{
> atomic_set(&(page)->_mapcount, -1);
>}
>
>int __page_mapcount(struct page *page);
># 870 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_mapcount(struct page *page)
>{
> if (__builtin_expect(!!(PageCompound(page)), 0))
>  return __page_mapcount(page);
> return atomic_read(&page->_mapcount) + 1;
>}
>
>
>int total_mapcount(struct page *page);
>int page_trans_huge_mapcount(struct page *page, int *total_mapcount);
># 895 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *virt_to_head_page(const void *x)
>{
> struct page *page = (((struct page *)vmemmap_base) + (__phys_addr_nodebug((unsigned long)(x)) >> 12));
>
> return ((typeof(page))_compound_head(page));
>}
>
>void __put_page(struct page *page);
>
>void put_pages_list(struct list_head *pages);
>
>void split_page(struct page *page, unsigned int order);
>void copy_huge_page(struct page *dst, struct page *src);
>
>
>
>
>
>
>typedef void compound_page_dtor(struct page *);
>
>
>enum compound_dtor_id {
> NULL_COMPOUND_DTOR,
> COMPOUND_PAGE_DTOR,
>
> HUGETLB_PAGE_DTOR,
>
>
> TRANSHUGE_PAGE_DTOR,
>
> NR_COMPOUND_DTORS,
>};
>extern compound_page_dtor * const compound_page_dtors[NR_COMPOUND_DTORS];
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_compound_page_dtor(struct page *page,
>  enum compound_dtor_id compound_dtor)
>{
> ((void)(sizeof(( long)(compound_dtor >= NR_COMPOUND_DTORS))));
> page[1].compound_dtor = compound_dtor;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void destroy_compound_page(struct page *page)
>{
> ((void)(sizeof(( long)(page[1].compound_dtor >= NR_COMPOUND_DTORS))));
> compound_page_dtors[page[1].compound_dtor](page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int compound_order(struct page *page)
>{
> if (!PageHead(page))
>  return 0;
> return page[1].compound_order;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool hpage_pincount_available(struct page *page)
>{
>
>
>
>
>
> page = ((typeof(page))_compound_head(page));
> return PageCompound(page) && compound_order(page) > 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int head_compound_pincount(struct page *head)
>{
> return atomic_read(compound_pincount_ptr(head));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int compound_pincount(struct page *page)
>{
> ((void)(sizeof(( long)(!hpage_pincount_available(page)))));
> page = ((typeof(page))_compound_head(page));
> return head_compound_pincount(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_compound_order(struct page *page, unsigned int order)
>{
> page[1].compound_order = order;
> page[1].compound_nr = 1U << order;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long compound_nr(struct page *page)
>{
> if (!PageHead(page))
>  return 1;
> return page[1].compound_nr;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_size(struct page *page)
>{
> return ((1UL) << 12) << compound_order(page);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int page_shift(struct page *page)
>{
> return 12 + compound_order(page);
>}
>
>void free_compound_page(struct page *page);
># 1008 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t maybe_mkwrite(pte_t pte, struct vm_area_struct *vma)
>{
> if (__builtin_expect(!!(vma->vm_flags & 0x00000002), 1))
>  pte = pte_mkwrite(pte);
> return pte;
>}
>
>vm_fault_t do_set_pmd(struct vm_fault *vmf, struct page *page);
>void do_set_pte(struct vm_fault *vmf, struct page *page, unsigned long addr);
>
>vm_fault_t finish_fault(struct vm_fault *vmf);
>vm_fault_t finish_mkwrite_fault(struct vm_fault *vmf);
># 1083 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern struct static_key_false devmap_managed_key;
>
>bool __put_devmap_managed_page(struct page *page);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool put_devmap_managed_page(struct page *page)
>{
> if (!({ bool branch; if (__builtin_types_compatible_p(typeof(*&devmap_managed_key), struct static_key_true)) branch = arch_static_branch_jump(&(&devmap_managed_key)->key, false); else if (__builtin_types_compatible_p(typeof(*&devmap_managed_key), struct static_key_false)) branch = arch_static_branch(&(&devmap_managed_key)->key, false); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 0); }))
>  return false;
> if (!is_zone_device_page(page))
>  return false;
> return __put_devmap_managed_page(page);
>}
># 1106 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void get_page(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
>
>
>
>
> ((void)(sizeof(( long)(((unsigned int) page_ref_count(page) + 127u <= 127u)))));
> page_ref_inc(page);
>}
>
>bool __attribute__((__warn_unused_result__)) try_grab_page(struct page *page, unsigned int flags);
>struct page *try_grab_compound_head(struct page *page, int refs,
>        unsigned int flags);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__warn_unused_result__)) bool try_get_page(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
> if (({ int __ret_warn_on = !!(page_ref_count(page) <= 0); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"), "i" (1125), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("246" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "246" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }))
>  return false;
> page_ref_inc(page);
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_page(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
>
>
>
>
>
> if (put_devmap_managed_page(page))
>  return;
>
> if (put_page_testzero(page))
>  __put_page(page);
>}
># 1179 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>void unpin_user_page(struct page *page);
>void unpin_user_pages_dirty_lock(struct page **pages, unsigned long npages,
>     bool make_dirty);
>void unpin_user_page_range_dirty_lock(struct page *page, unsigned long npages,
>          bool make_dirty);
>void unpin_user_pages(struct page **pages, unsigned long npages);
># 1212 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_maybe_dma_pinned(struct page *page)
>{
> if (hpage_pincount_available(page))
>  return compound_pincount(page) > 0;
># 1225 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
> return ((unsigned int)page_ref_count(((typeof(page))_compound_head(page)))) >=
>  (1U << 10);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_cow_mapping(vm_flags_t flags)
>{
> return (flags & (0x00000008 | 0x00000020)) == 0x00000020;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_needs_cow_for_dma(struct vm_area_struct *vma,
>       struct page *page)
>{
> if (!is_cow_mapping(vma->vm_flags))
>  return false;
>
> if (!test_bit(28, &vma->vm_mm->flags))
>  return false;
>
> return page_maybe_dma_pinned(page);
>}
># 1262 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_zone_id(struct page *page)
>{
> return (page->flags >> ((((((sizeof(unsigned long)*8) - 0) - 10) < ((((sizeof(unsigned long)*8) - 0) - 10) - 3)) ? (((sizeof(unsigned long)*8) - 0) - 10) : ((((sizeof(unsigned long)*8) - 0) - 10) - 3)) * ((10 + 3) != 0))) & ((1UL << (10 + 3)) - 1);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_to_nid(const struct page *page)
>{
> struct page *p = (struct page *)page;
>
> return (({ ((void)(sizeof(( long)(PagePoisoned(p))))); p; })->flags >> ((((sizeof(unsigned long)*8) - 0) - 10) * (10 != 0))) & ((1UL << 10) - 1);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_pid_to_cpupid(int cpu, int pid)
>{
> return ((cpu & ((1 << 13)-1)) << 8) | (pid & ((1 << 8)-1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpupid_to_pid(int cpupid)
>{
> return cpupid & ((1 << 8)-1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpupid_to_cpu(int cpupid)
>{
> return (cpupid >> 8) & ((1 << 13)-1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpupid_to_nid(int cpupid)
>{
> return cpu_to_node(cpupid_to_cpu(cpupid));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpupid_pid_unset(int cpupid)
>{
> return cpupid_to_pid(cpupid) == (-1 & ((1 << 8)-1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cpupid_cpu_unset(int cpupid)
>{
> return cpupid_to_cpu(cpupid) == (-1 & ((1 << 13)-1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __cpupid_match_pid(pid_t task_pid, int cpupid)
>{
> return (task_pid & ((1 << 8)-1)) == cpupid_to_pid(cpupid);
>}
># 1330 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_cpupid_last(struct page *page)
>{
> return (page->flags >> ((((((sizeof(unsigned long)*8) - 0) - 10) - 3) - (8 +13)) * ((8 +13) != 0))) & ((1UL << (8 +13)) - 1);
>}
>
>extern int page_cpupid_xchg_last(struct page *page, int cpupid);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_cpupid_reset_last(struct page *page)
>{
> page->flags |= ((1UL << (8 +13)) - 1) << ((((((sizeof(unsigned long)*8) - 0) - 10) - 3) - (8 +13)) * ((8 +13) != 0));
>}
># 1425 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 page_kasan_tag(const struct page *page)
>{
> return 0xff;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_kasan_tag_set(struct page *page, u8 tag) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_kasan_tag_reset(struct page *page) { }
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct zone *page_zone(const struct page *page)
>{
> return &(node_data[page_to_nid(page)])->node_zones[page_zonenum(page)];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pg_data_t *page_pgdat(const struct page *page)
>{
> return (node_data[page_to_nid(page)]);
>}
># 1460 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_longterm_pinnable_page(struct page *page)
>{
>
> int mt = get_pfnblock_flags_mask(page, (unsigned long)((page) - ((struct page *)vmemmap_base)), ((1UL << 3) - 1));
>
> if (mt == MIGRATE_CMA || mt == MIGRATE_ISOLATE)
>  return false;
>
>
> if (is_zero_pfn((unsigned long)((page) - ((struct page *)vmemmap_base))))
>  return true;
>
>
> if (is_device_coherent_page(page))
>  return false;
>
>
> return !is_zone_movable_page(page);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_zone(struct page *page, enum zone_type zone)
>{
> page->flags &= ~(((1UL << 3) - 1) << (((((sizeof(unsigned long)*8) - 0) - 10) - 3) * (3 != 0)));
> page->flags |= (zone & ((1UL << 3) - 1)) << (((((sizeof(unsigned long)*8) - 0) - 10) - 3) * (3 != 0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_node(struct page *page, unsigned long node)
>{
> page->flags &= ~(((1UL << 10) - 1) << ((((sizeof(unsigned long)*8) - 0) - 10) * (10 != 0)));
> page->flags |= (node & ((1UL << 10) - 1)) << ((((sizeof(unsigned long)*8) - 0) - 10) * (10 != 0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_links(struct page *page, enum zone_type zone,
> unsigned long node, unsigned long pfn)
>{
> set_page_zone(page, zone);
> set_page_node(page, node);
>
>
>
>}
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/vm_event_item.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/vm_event_item.h"
>enum vm_event_item { PGPGIN, PGPGOUT, PSWPIN, PSWPOUT,
>  PGALLOC_DMA, PGALLOC_DMA32, PGALLOC_NORMAL, PGALLOC_MOVABLE,
>  ALLOCSTALL_DMA, ALLOCSTALL_DMA32, ALLOCSTALL_NORMAL, ALLOCSTALL_MOVABLE,
>  PGSCAN_SKIP_DMA, PGSCAN_SKIP_DMA32, PGSCAN_SKIP_NORMAL, PGSCAN_SKIP_MOVABLE,
>  PGFREE, PGACTIVATE, PGDEACTIVATE, PGLAZYFREE,
>  PGFAULT, PGMAJFAULT,
>  PGLAZYFREED,
>  PGREFILL,
>  PGREUSE,
>  PGSTEAL_KSWAPD,
>  PGSTEAL_DIRECT,
>  PGDEMOTE_KSWAPD,
>  PGDEMOTE_DIRECT,
>  PGSCAN_KSWAPD,
>  PGSCAN_DIRECT,
>  PGSCAN_DIRECT_THROTTLE,
>  PGSCAN_ANON,
>  PGSCAN_FILE,
>  PGSTEAL_ANON,
>  PGSTEAL_FILE,
>
>  PGSCAN_ZONE_RECLAIM_FAILED,
>
>  PGINODESTEAL, SLABS_SCANNED, KSWAPD_INODESTEAL,
>  KSWAPD_LOW_WMARK_HIT_QUICKLY, KSWAPD_HIGH_WMARK_HIT_QUICKLY,
>  PAGEOUTRUN, PGROTATED,
>  DROP_PAGECACHE, DROP_SLAB,
>  OOM_KILL,
>
>  NUMA_PTE_UPDATES,
>  NUMA_HUGE_PTE_UPDATES,
>  NUMA_HINT_FAULTS,
>  NUMA_HINT_FAULTS_LOCAL,
>  NUMA_PAGE_MIGRATE,
>
>
>  PGMIGRATE_SUCCESS, PGMIGRATE_FAIL,
>  THP_MIGRATION_SUCCESS,
>  THP_MIGRATION_FAIL,
>  THP_MIGRATION_SPLIT,
>
>
>  COMPACTMIGRATE_SCANNED, COMPACTFREE_SCANNED,
>  COMPACTISOLATED,
>  COMPACTSTALL, COMPACTFAIL, COMPACTSUCCESS,
>  KCOMPACTD_WAKE,
>  KCOMPACTD_MIGRATE_SCANNED, KCOMPACTD_FREE_SCANNED,
>
>
>  HTLB_BUDDY_PGALLOC, HTLB_BUDDY_PGALLOC_FAIL,
>
>
>  CMA_ALLOC_SUCCESS,
>  CMA_ALLOC_FAIL,
>
>  UNEVICTABLE_PGCULLED,
>  UNEVICTABLE_PGSCANNED,
>  UNEVICTABLE_PGRESCUED,
>  UNEVICTABLE_PGMLOCKED,
>  UNEVICTABLE_PGMUNLOCKED,
>  UNEVICTABLE_PGCLEARED,
>  UNEVICTABLE_PGSTRANDED,
>
>  THP_FAULT_ALLOC,
>  THP_FAULT_FALLBACK,
>  THP_FAULT_FALLBACK_CHARGE,
>  THP_COLLAPSE_ALLOC,
>  THP_COLLAPSE_ALLOC_FAILED,
>  THP_FILE_ALLOC,
>  THP_FILE_FALLBACK,
>  THP_FILE_FALLBACK_CHARGE,
>  THP_FILE_MAPPED,
>  THP_SPLIT_PAGE,
>  THP_SPLIT_PAGE_FAILED,
>  THP_DEFERRED_SPLIT_PAGE,
>  THP_SPLIT_PMD,
>
>  THP_SPLIT_PUD,
>
>  THP_ZERO_PAGE_ALLOC,
>  THP_ZERO_PAGE_ALLOC_FAILED,
>  THP_SWPOUT,
>  THP_SWPOUT_FALLBACK,
>
>
>  BALLOON_INFLATE,
>  BALLOON_DEFLATE,
>
>  BALLOON_MIGRATE,
># 127 "/usr/src/linux-5.14.21-150500.53/include/linux/vm_event_item.h"
>  SWAP_RA,
>  SWAP_RA_HIT,
>
>
>  DIRECT_MAP_LEVEL2_SPLIT,
>  DIRECT_MAP_LEVEL3_SPLIT,
>
>  NR_VM_EVENT_ITEMS
>};
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/static_key.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h" 2
>
>
>extern int sysctl_stat_interval;
>
>
>
>
>extern int sysctl_vm_numa_stat;
>extern struct static_key_true vm_numa_stat_key;
>int sysctl_vm_numa_stat_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *length, loff_t *ppos);
>
>
>struct reclaim_stat {
> unsigned nr_dirty;
> unsigned nr_unqueued_dirty;
> unsigned nr_congested;
> unsigned nr_writeback;
> unsigned nr_immediate;
> unsigned nr_pageout;
> unsigned nr_activate[2];
> unsigned nr_ref_keep;
> unsigned nr_unmap_fail;
> unsigned nr_lazyfree_fail;
>};
>
>enum writeback_stat_item {
> NR_DIRTY_THRESHOLD,
> NR_DIRTY_BG_THRESHOLD,
> NR_VM_WRITEBACK_STAT_ITEMS,
>};
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h"
>struct vm_event_state {
> unsigned long event[NR_VM_EVENT_ITEMS];
>};
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_vm_event_states; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct vm_event_state) vm_event_states;
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __count_vm_event(enum vm_event_item item)
>{
> do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void count_vm_event(enum vm_event_item item)
>{
> do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __count_vm_events(enum vm_event_item item, long delta)
>{
> do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) delta) & 0xff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) delta) & 0xffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) delta) & 0xffffffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u64 pto_val__ = ((u64)(delta)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void count_vm_events(enum vm_event_item item, long delta)
>{
> do { do { const void *__vpp_verify = (typeof((&(vm_event_states.event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(vm_event_states.event[item])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) delta) & 0xff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) delta) & 0xffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) delta) & 0xffffffff)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((vm_event_states.event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item]))); }); else do { u64 pto_val__ = ((u64)(delta)); if (0) { typeof((vm_event_states.event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((vm_event_states.event[item])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>extern void all_vm_events(unsigned long *);
>
>extern void vm_events_fold_cpu(int cpu);
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h"
>extern atomic_long_t vm_zone_stat[NR_VM_ZONE_STAT_ITEMS];
>extern atomic_long_t vm_node_stat[NR_VM_NODE_STAT_ITEMS];
>extern atomic_long_t vm_numa_event[NR_VM_NUMA_EVENT_ITEMS];
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zone_numa_event_add(long x, struct zone *zone,
>    enum numa_stat_item item)
>{
> atomic_long_add(x, &zone->vm_numa_event[item]);
> atomic_long_add(x, &vm_numa_event[item]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long zone_numa_event_state(struct zone *zone,
>     enum numa_stat_item item)
>{
> return atomic_long_read(&zone->vm_numa_event[item]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>global_numa_event_state(enum numa_stat_item item)
>{
> return atomic_long_read(&vm_numa_event[item]);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zone_page_state_add(long x, struct zone *zone,
>     enum zone_stat_item item)
>{
> atomic_long_add(x, &zone->vm_stat[item]);
> atomic_long_add(x, &vm_zone_stat[item]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void node_page_state_add(long x, struct pglist_data *pgdat,
>     enum node_stat_item item)
>{
> atomic_long_add(x, &pgdat->vm_stat[item]);
> atomic_long_add(x, &vm_node_stat[item]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long global_zone_page_state(enum zone_stat_item item)
>{
> long x = atomic_long_read(&vm_zone_stat[item]);
>
> if (x < 0)
>  x = 0;
>
> return x;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long global_node_page_state_pages(enum node_stat_item item)
>{
> long x = atomic_long_read(&vm_node_stat[item]);
>
> if (x < 0)
>  x = 0;
>
> return x;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long global_node_page_state(enum node_stat_item item)
>{
> ((void)(sizeof(( long)(vmstat_item_in_bytes(item)))));
>
> return global_node_page_state_pages(item);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long zone_page_state(struct zone *zone,
>     enum zone_stat_item item)
>{
> long x = atomic_long_read(&zone->vm_stat[item]);
>
> if (x < 0)
>  x = 0;
>
> return x;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long zone_page_state_snapshot(struct zone *zone,
>     enum zone_stat_item item)
>{
> long x = atomic_long_read(&zone->vm_stat[item]);
>
>
> int cpu;
> for (((cpu)) = -1; ((cpu)) = cpumask_next(((cpu)), (((const struct cpumask *)&__cpu_online_mask))), ((cpu)) < nr_cpu_ids;)
>  x += ({ do { const void *__vpp_verify = (typeof((zone->per_cpu_zonestats) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((zone->per_cpu_zonestats))) *)((zone->per_cpu_zonestats)))); (typeof((typeof(*((zone->per_cpu_zonestats))) *)((zone->per_cpu_zonestats)))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })->vm_stat_diff[item];
>
> if (x < 0)
>  x = 0;
>
> return x;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>__count_numa_event(struct zone *zone, enum numa_stat_item item)
>{
> struct per_cpu_zonestat *pzstats = zone->per_cpu_zonestats;
>
> do { do { const void *__vpp_verify = (typeof((&(pzstats->vm_numa_event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(pzstats->vm_numa_event[item])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>__count_numa_events(struct zone *zone, enum numa_stat_item item, long delta)
>{
> struct per_cpu_zonestat *pzstats = zone->per_cpu_zonestats;
>
> do { do { const void *__vpp_verify = (typeof((&(pzstats->vm_numa_event[item])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(pzstats->vm_numa_event[item])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) delta) & 0xff)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) delta) & 0xffff)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) delta) & 0xffffffff)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(delta) && ((delta) == 1 || (delta) == -1)) ? (int)(delta) : 0; if (0) { typeof((pzstats->vm_numa_event[item])) pao_tmp__; pao_tmp__ = (delta); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item]))); }); else do { u64 pto_val__ = ((u64)(delta)); if (0) { typeof((pzstats->vm_numa_event[item])) pto_tmp__; pto_tmp__ = (delta); (void)pto_tmp__; } asm ("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((pzstats->vm_numa_event[item])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>extern unsigned long sum_zone_node_page_state(int node,
>           enum zone_stat_item item);
>extern unsigned long sum_zone_numa_event_state(int node, enum numa_stat_item item);
>extern unsigned long node_page_state(struct pglist_data *pgdat,
>      enum node_stat_item item);
>extern unsigned long node_page_state_pages(struct pglist_data *pgdat,
>        enum node_stat_item item);
>extern void fold_vm_numa_events(void);
># 276 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h"
>void __mod_zone_page_state(struct zone *, enum zone_stat_item item, long);
>void __inc_zone_page_state(struct page *, enum zone_stat_item);
>void __dec_zone_page_state(struct page *, enum zone_stat_item);
>
>void __mod_node_page_state(struct pglist_data *, enum node_stat_item item, long);
>void __inc_node_page_state(struct page *, enum node_stat_item);
>void __dec_node_page_state(struct page *, enum node_stat_item);
>
>void mod_zone_page_state(struct zone *, enum zone_stat_item, long);
>void inc_zone_page_state(struct page *, enum zone_stat_item);
>void dec_zone_page_state(struct page *, enum zone_stat_item);
>
>void mod_node_page_state(struct pglist_data *, enum node_stat_item, long);
>void inc_node_page_state(struct page *, enum node_stat_item);
>void dec_node_page_state(struct page *, enum node_stat_item);
>
>extern void inc_node_state(struct pglist_data *, enum node_stat_item);
>extern void __inc_zone_state(struct zone *, enum zone_stat_item);
>extern void __inc_node_state(struct pglist_data *, enum node_stat_item);
>extern void dec_zone_state(struct zone *, enum zone_stat_item);
>extern void __dec_zone_state(struct zone *, enum zone_stat_item);
>extern void __dec_node_state(struct pglist_data *, enum node_stat_item);
>
>void quiet_vmstat(void);
>void cpu_vm_stats_fold(int cpu);
>void refresh_zone_stat_thresholds(void);
>
>struct ctl_table;
>int vmstat_refresh(struct ctl_table *, int write, void *buffer, size_t *lenp,
>  loff_t *ppos);
>
>void drain_zonestat(struct zone *zone, struct per_cpu_zonestat *);
>
>int calculate_pressure_threshold(struct zone *zone);
>int calculate_normal_threshold(struct zone *zone);
>void set_pgdat_percpu_threshold(pg_data_t *pgdat,
>    int (*calculate_pressure)(struct zone *));
># 418 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __mod_zone_freepage_state(struct zone *zone, int nr_pages,
>          int migratetype)
>{
> __mod_zone_page_state(zone, NR_FREE_PAGES, nr_pages);
> if (__builtin_expect(!!((migratetype) == MIGRATE_CMA), 0))
>  __mod_zone_page_state(zone, NR_FREE_CMA_PAGES, nr_pages);
>}
>
>extern const char * const vmstat_text[];
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *zone_stat_name(enum zone_stat_item item)
>{
> return vmstat_text[item];
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *numa_stat_name(enum numa_stat_item item)
>{
> return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
>      item];
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *node_stat_name(enum node_stat_item item)
>{
> return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
>      NR_VM_NUMA_EVENT_ITEMS +
>      item];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *lru_list_name(enum lru_list lru)
>{
> return node_stat_name(NR_LRU_BASE + lru) + 3;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *writeback_stat_name(enum writeback_stat_item item)
>{
> return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
>      NR_VM_NUMA_EVENT_ITEMS +
>      NR_VM_NODE_STAT_ITEMS +
>      item];
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *vm_event_name(enum vm_event_item item)
>{
> return vmstat_text[NR_VM_ZONE_STAT_ITEMS +
>      NR_VM_NUMA_EVENT_ITEMS +
>      NR_VM_NODE_STAT_ITEMS +
>      NR_VM_WRITEBACK_STAT_ITEMS +
>      item];
>}
>
>
>
>
>void __mod_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
>   int val);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mod_lruvec_state(struct lruvec *lruvec,
>        enum node_stat_item idx, int val)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __mod_lruvec_state(lruvec, idx, val);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>void __mod_lruvec_page_state(struct page *page,
>        enum node_stat_item idx, int val);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mod_lruvec_page_state(struct page *page,
>      enum node_stat_item idx, int val)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __mod_lruvec_page_state(page, idx, val);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
># 528 "/usr/src/linux-5.14.21-150500.53/include/linux/vmstat.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inc_lruvec_state(struct lruvec *lruvec,
>        enum node_stat_item idx)
>{
> mod_lruvec_state(lruvec, idx, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __inc_lruvec_page_state(struct page *page,
>        enum node_stat_item idx)
>{
> __mod_lruvec_page_state(page, idx, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __dec_lruvec_page_state(struct page *page,
>        enum node_stat_item idx)
>{
> __mod_lruvec_page_state(page, idx, -1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inc_lruvec_page_state(struct page *page,
>      enum node_stat_item idx)
>{
> mod_lruvec_page_state(page, idx, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dec_lruvec_page_state(struct page *page,
>      enum node_stat_item idx)
>{
> mod_lruvec_page_state(page, idx, -1);
>}
># 1512 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h" 2
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void *lowmem_page_address(const struct page *page)
>{
> return ((void *)((unsigned long)(((phys_addr_t)((unsigned long)((page) - ((struct page *)vmemmap_base))) << 12))+((unsigned long)page_offset_base)));
>}
># 1546 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern void *page_rmapping(struct page *page);
>extern struct anon_vma *page_anon_vma(struct page *page);
>extern struct address_space *page_mapping(struct page *page);
>
>extern struct address_space *__page_file_mapping(struct page *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct address_space *page_file_mapping(struct page *page)
>{
> if (__builtin_expect(!!(PageSwapCache(page)), 0))
>  return __page_file_mapping(page);
>
> return page->mapping;
>}
>
>extern unsigned long __page_file_index(struct page *page);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_index(struct page *page)
>{
> if (__builtin_expect(!!(PageSwapCache(page)), 0))
>  return __page_file_index(page);
> return page->index;
>}
>
>bool page_mapped(struct page *page);
>struct address_space *page_mapping(struct page *page);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_is_pfmemalloc(const struct page *page)
>{
>
>
>
>
>
> return (uintptr_t)page->lru.next & ((((1UL))) << (1));
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_pfmemalloc(struct page *page)
>{
> page->lru.next = (void *)((((1UL))) << (1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_page_pfmemalloc(struct page *page)
>{
> page->lru.next = ((void *)0);
>}
>
>
>
>
>extern void pagefault_out_of_memory(void);
># 1620 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern void show_free_areas(unsigned int flags, nodemask_t *nodemask);
>
>
>extern bool can_do_mlock(void);
>
>
>
>extern int user_shm_lock(size_t, struct ucounts *);
>extern void user_shm_unlock(size_t, struct ucounts *);
>
>
>
>
>struct zap_details {
> struct address_space *zap_mapping;
> struct page *single_page;
>};
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool
>zap_skip_check_mapping(struct zap_details *details, struct page *page)
>{
> if (!details || !page)
>  return false;
>
> return details->zap_mapping &&
>     (details->zap_mapping != page_rmapping(page));
>}
>
>struct page *vm_normal_page(struct vm_area_struct *vma, unsigned long addr,
>        pte_t pte);
>struct page *vm_normal_page_pmd(struct vm_area_struct *vma, unsigned long addr,
>    pmd_t pmd);
>
>void zap_vma_ptes(struct vm_area_struct *vma, unsigned long address,
>    unsigned long size);
>void zap_page_range(struct vm_area_struct *vma, unsigned long address,
>      unsigned long size);
>void unmap_vmas(struct mmu_gather *tlb, struct vm_area_struct *start_vma,
>  unsigned long start, unsigned long end);
>
>struct mmu_notifier_range;
>
>void free_pgd_range(struct mmu_gather *tlb, unsigned long addr,
>  unsigned long end, unsigned long floor, unsigned long ceiling);
>int
>copy_page_range(struct vm_area_struct *dst_vma, struct vm_area_struct *src_vma);
>int follow_invalidate_pte(struct mm_struct *mm, unsigned long address,
>     struct mmu_notifier_range *range, pte_t **ptepp,
>     pmd_t **pmdpp, spinlock_t **ptlp);
>int follow_pte(struct mm_struct *mm, unsigned long address,
>        pte_t **ptepp, spinlock_t **ptlp);
>int follow_pfn(struct vm_area_struct *vma, unsigned long address,
> unsigned long *pfn);
>int follow_phys(struct vm_area_struct *vma, unsigned long address,
>  unsigned int flags, unsigned long *prot, resource_size_t *phys);
>int generic_access_phys(struct vm_area_struct *vma, unsigned long addr,
>   void *buf, int len, int write);
>
>extern void truncate_pagecache(struct inode *inode, loff_t new);
>extern void truncate_setsize(struct inode *inode, loff_t newsize);
>void pagecache_isize_extended(struct inode *inode, loff_t from, loff_t to);
>void truncate_pagecache_range(struct inode *inode, loff_t offset, loff_t end);
>int truncate_inode_page(struct address_space *mapping, struct page *page);
>int generic_error_remove_page(struct address_space *mapping, struct page *page);
>int invalidate_inode_page(struct page *page);
>
>
>extern vm_fault_t handle_mm_fault(struct vm_area_struct *vma,
>      unsigned long address, unsigned int flags,
>      struct pt_regs *regs);
>extern int fixup_user_fault(struct mm_struct *mm,
>       unsigned long address, unsigned int fault_flags,
>       bool *unlocked);
>void unmap_mapping_page(struct page *page);
>void unmap_mapping_pages(struct address_space *mapping,
>  unsigned long start, unsigned long nr, bool even_cows);
>void unmap_mapping_range(struct address_space *mapping,
>  loff_t const holebegin, loff_t const holelen, int even_cows);
># 1725 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unmap_shared_mapping_range(struct address_space *mapping,
>  loff_t const holebegin, loff_t const holelen)
>{
> unmap_mapping_range(mapping, holebegin, holelen, 0);
>}
>
>extern int access_process_vm(struct task_struct *tsk, unsigned long addr,
>  void *buf, int len, unsigned int gup_flags);
>extern int access_remote_vm(struct mm_struct *mm, unsigned long addr,
>  void *buf, int len, unsigned int gup_flags);
>extern int __access_remote_vm(struct mm_struct *mm, unsigned long addr,
>         void *buf, int len, unsigned int gup_flags);
>
>long get_user_pages_remote(struct mm_struct *mm,
>       unsigned long start, unsigned long nr_pages,
>       unsigned int gup_flags, struct page **pages,
>       struct vm_area_struct **vmas, int *locked);
>long pin_user_pages_remote(struct mm_struct *mm,
>      unsigned long start, unsigned long nr_pages,
>      unsigned int gup_flags, struct page **pages,
>      struct vm_area_struct **vmas, int *locked);
>long get_user_pages(unsigned long start, unsigned long nr_pages,
>       unsigned int gup_flags, struct page **pages,
>       struct vm_area_struct **vmas);
>long pin_user_pages(unsigned long start, unsigned long nr_pages,
>      unsigned int gup_flags, struct page **pages,
>      struct vm_area_struct **vmas);
>long get_user_pages_locked(unsigned long start, unsigned long nr_pages,
>      unsigned int gup_flags, struct page **pages, int *locked);
>long pin_user_pages_locked(unsigned long start, unsigned long nr_pages,
>      unsigned int gup_flags, struct page **pages, int *locked);
>long get_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
>      struct page **pages, unsigned int gup_flags);
>long pin_user_pages_unlocked(unsigned long start, unsigned long nr_pages,
>      struct page **pages, unsigned int gup_flags);
>
>int get_user_pages_fast(unsigned long start, int nr_pages,
>   unsigned int gup_flags, struct page **pages);
>int pin_user_pages_fast(unsigned long start, int nr_pages,
>   unsigned int gup_flags, struct page **pages);
>
>int account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc);
>int __account_locked_vm(struct mm_struct *mm, unsigned long pages, bool inc,
>   struct task_struct *task, bool bypass_rlim);
>
>struct kvec;
>int get_kernel_pages(const struct kvec *iov, int nr_pages, int write,
>   struct page **pages);
>struct page *get_dump_page(unsigned long addr);
>
>extern int try_to_release_page(struct page * page, gfp_t gfp_mask);
>extern void do_invalidatepage(struct page *page, unsigned int offset,
>         unsigned int length);
>
>int redirty_page_for_writepage(struct writeback_control *wbc,
>    struct page *page);
>void account_page_cleaned(struct page *page, struct address_space *mapping,
>     struct bdi_writeback *wb);
>int set_page_dirty(struct page *page);
>int set_page_dirty_lock(struct page *page);
>void __cancel_dirty_page(struct page *page);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cancel_dirty_page(struct page *page)
>{
>
> if (PageDirty(page))
>  __cancel_dirty_page(page);
>}
>int clear_page_dirty_for_io(struct page *page);
>
>int get_cmdline(struct task_struct *task, char *buffer, int buflen);
>
>extern unsigned long move_page_tables(struct vm_area_struct *vma,
>  unsigned long old_addr, struct vm_area_struct *new_vma,
>  unsigned long new_addr, unsigned long len,
>  bool need_rmap_locks);
># 1817 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern unsigned long change_protection(struct vm_area_struct *vma, unsigned long start,
>         unsigned long end, pgprot_t newprot,
>         unsigned long cp_flags);
>extern int mprotect_fixup(struct vm_area_struct *vma,
>     struct vm_area_struct **pprev, unsigned long start,
>     unsigned long end, unsigned long newflags);
>
>
>
>
>int get_user_pages_fast_only(unsigned long start, int nr_pages,
>        unsigned int gup_flags, struct page **pages);
>int pin_user_pages_fast_only(unsigned long start, int nr_pages,
>        unsigned int gup_flags, struct page **pages);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool get_user_page_fast_only(unsigned long addr,
>   unsigned int gup_flags, struct page **pagep)
>{
> return get_user_pages_fast_only(addr, 1, gup_flags, pagep) == 1;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_mm_counter(struct mm_struct *mm, int member)
>{
> long val = atomic_long_read(&mm->rss_stat.count[member]);
>
>
>
>
>
>
> if (val < 0)
>  val = 0;
>
> return (unsigned long)val;
>}
>
>void mm_trace_rss_stat(struct mm_struct *mm, int member, long count);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void add_mm_counter(struct mm_struct *mm, int member, long value)
>{
> long count = atomic_long_add_return(value, &mm->rss_stat.count[member]);
>
> mm_trace_rss_stat(mm, member, count);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inc_mm_counter(struct mm_struct *mm, int member)
>{
> long count = atomic_long_inc_return(&mm->rss_stat.count[member]);
>
> mm_trace_rss_stat(mm, member, count);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dec_mm_counter(struct mm_struct *mm, int member)
>{
> long count = atomic_long_dec_return(&mm->rss_stat.count[member]);
>
> mm_trace_rss_stat(mm, member, count);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mm_counter_file(struct page *page)
>{
> if (PageSwapBacked(page))
>  return MM_SHMEMPAGES;
> return MM_FILEPAGES;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mm_counter(struct page *page)
>{
> if (PageAnon(page))
>  return MM_ANONPAGES;
> return mm_counter_file(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_mm_rss(struct mm_struct *mm)
>{
> return get_mm_counter(mm, MM_FILEPAGES) +
>  get_mm_counter(mm, MM_ANONPAGES) +
>  get_mm_counter(mm, MM_SHMEMPAGES);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_mm_hiwater_rss(struct mm_struct *mm)
>{
> return __builtin_choose_expr(((!!(sizeof((typeof(mm->hiwater_rss) *)1 == (typeof(get_mm_rss(mm)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(mm->hiwater_rss) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(get_mm_rss(mm)) * 0l)) : (int *)8))))), ((mm->hiwater_rss) > (get_mm_rss(mm)) ? (mm->hiwater_rss) : (get_mm_rss(mm))), ({ typeof(mm->hiwater_rss) __UNIQUE_ID___x247 = (mm->hiwater_rss); typeof(get_mm_rss(mm)) __UNIQUE_ID___y248 = (get_mm_rss(mm)); ((__UNIQUE_ID___x247) > (__UNIQUE_ID___y248) ? (__UNIQUE_ID___x247) : (__UNIQUE_ID___y248)); }));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_mm_hiwater_vm(struct mm_struct *mm)
>{
> return __builtin_choose_expr(((!!(sizeof((typeof(mm->hiwater_vm) *)1 == (typeof(mm->total_vm) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(mm->hiwater_vm) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(mm->total_vm) * 0l)) : (int *)8))))), ((mm->hiwater_vm) > (mm->total_vm) ? (mm->hiwater_vm) : (mm->total_vm)), ({ typeof(mm->hiwater_vm) __UNIQUE_ID___x249 = (mm->hiwater_vm); typeof(mm->total_vm) __UNIQUE_ID___y250 = (mm->total_vm); ((__UNIQUE_ID___x249) > (__UNIQUE_ID___y250) ? (__UNIQUE_ID___x249) : (__UNIQUE_ID___y250)); }));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_hiwater_rss(struct mm_struct *mm)
>{
> unsigned long _rss = get_mm_rss(mm);
>
> if ((mm)->hiwater_rss < _rss)
>  (mm)->hiwater_rss = _rss;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void update_hiwater_vm(struct mm_struct *mm)
>{
> if (mm->hiwater_vm < mm->total_vm)
>  mm->hiwater_vm = mm->total_vm;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void reset_mm_hiwater_rss(struct mm_struct *mm)
>{
> mm->hiwater_rss = get_mm_rss(mm);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void setmax_mm_hiwater_rss(unsigned long *maxrss,
>      struct mm_struct *mm)
>{
> unsigned long hiwater_rss = get_mm_hiwater_rss(mm);
>
> if (*maxrss < hiwater_rss)
>  *maxrss = hiwater_rss;
>}
>
>
>void sync_mm_rss(struct mm_struct *mm);
># 1965 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>int vma_wants_writenotify(struct vm_area_struct *vma, pgprot_t vm_page_prot);
>
>extern pte_t *__get_locked_pte(struct mm_struct *mm, unsigned long addr,
>          spinlock_t **ptl);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pte_t *get_locked_pte(struct mm_struct *mm, unsigned long addr,
>        spinlock_t **ptl)
>{
> pte_t *ptep;
> (ptep = __get_locked_pte(mm, addr, ptl));
> return ptep;
>}
># 1984 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>int __p4d_alloc(struct mm_struct *mm, pgd_t *pgd, unsigned long address);
># 1997 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>int __pud_alloc(struct mm_struct *mm, p4d_t *p4d, unsigned long address);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_inc_nr_puds(struct mm_struct *mm)
>{
> if (0)
>  return;
> atomic_long_add(512 * sizeof(pud_t), &mm->pgtables_bytes);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_dec_nr_puds(struct mm_struct *mm)
>{
> if (0)
>  return;
> atomic_long_sub(512 * sizeof(pud_t), &mm->pgtables_bytes);
>}
># 2025 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>int __pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_inc_nr_pmds(struct mm_struct *mm)
>{
> if (0)
>  return;
> atomic_long_add(512 * sizeof(pmd_t), &mm->pgtables_bytes);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_dec_nr_pmds(struct mm_struct *mm)
>{
> if (0)
>  return;
> atomic_long_sub(512 * sizeof(pmd_t), &mm->pgtables_bytes);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_pgtables_bytes_init(struct mm_struct *mm)
>{
> atomic_long_set(&mm->pgtables_bytes, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long mm_pgtables_bytes(const struct mm_struct *mm)
>{
> return atomic_long_read(&mm->pgtables_bytes);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_inc_nr_ptes(struct mm_struct *mm)
>{
> atomic_long_add(512 * sizeof(pte_t), &mm->pgtables_bytes);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_dec_nr_ptes(struct mm_struct *mm)
>{
> atomic_long_sub(512 * sizeof(pte_t), &mm->pgtables_bytes);
>}
># 2074 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>int __pte_alloc(struct mm_struct *mm, pmd_t *pmd);
>int __pte_alloc_kernel(pmd_t *pmd);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) p4d_t *p4d_alloc(struct mm_struct *mm, pgd_t *pgd,
>  unsigned long address)
>{
> return (__builtin_expect(!!(pgd_none(*pgd)), 0) && __p4d_alloc(mm, pgd, address)) ?
>  ((void *)0) : p4d_offset(pgd, address);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pud_t *pud_alloc(struct mm_struct *mm, p4d_t *p4d,
>  unsigned long address)
>{
> return (__builtin_expect(!!(p4d_none(*p4d)), 0) && __pud_alloc(mm, p4d, address)) ?
>  ((void *)0) : pud_offset(p4d, address);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pmd_t *pmd_alloc(struct mm_struct *mm, pud_t *pud, unsigned long address)
>{
> return (__builtin_expect(!!(pud_none(*pud)), 0) && __pmd_alloc(mm, pud, address))?
>  ((void *)0): pmd_offset(pud, address);
>}
># 2111 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptlock_cache_init(void)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ptlock_alloc(struct page *page)
>{
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptlock_free(struct page *page)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *ptlock_ptr(struct page *page)
>{
> return &page->ptl;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pte_lockptr(struct mm_struct *mm, pmd_t *pmd)
>{
> return ptlock_ptr((((struct page *)vmemmap_base) + (pmd_pfn(*pmd))));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ptlock_init(struct page *page)
>{
>
>
>
>
>
>
>
> ((void)(sizeof(( long)(*(unsigned long *)&page->ptl))));
> if (!ptlock_alloc(page))
>  return false;
> do { spinlock_check(ptlock_ptr(page)); *(ptlock_ptr(page)) = (spinlock_t) { { .rlock = { .raw_lock = { { .val = { (0) } } }, } } }; } while (0);
> return true;
>}
># 2164 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pgtable_init(void)
>{
> ptlock_cache_init();
> pgtable_cache_init();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pgtable_pte_page_ctor(struct page *page)
>{
> if (!ptlock_init(page))
>  return false;
> __SetPageTable(page);
> inc_lruvec_page_state(page, NR_PAGETABLE);
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pgtable_pte_page_dtor(struct page *page)
>{
> ptlock_free(page);
> __ClearPageTable(page);
> dec_lruvec_page_state(page, NR_PAGETABLE);
>}
># 2215 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static struct page *pmd_to_page(pmd_t *pmd)
>{
> unsigned long mask = ~(512 * sizeof(pmd_t) - 1);
> return (((struct page *)vmemmap_base) + (__phys_addr_nodebug((unsigned long)((void *)((unsigned long) pmd & mask))) >> 12));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pmd_lockptr(struct mm_struct *mm, pmd_t *pmd)
>{
> return ptlock_ptr(pmd_to_page(pmd));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pmd_ptlock_init(struct page *page)
>{
>
> page->pmd_huge_pte = ((void *)0);
>
> return ptlock_init(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pmd_ptlock_free(struct page *page)
>{
>
> ((void)(sizeof(( long)(page->pmd_huge_pte))));
>
> ptlock_free(page);
>}
># 2258 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pmd_lock(struct mm_struct *mm, pmd_t *pmd)
>{
> spinlock_t *ptl = pmd_lockptr(mm, pmd);
> spin_lock(ptl);
> return ptl;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pgtable_pmd_page_ctor(struct page *page)
>{
> if (!pmd_ptlock_init(page))
>  return false;
> __SetPageTable(page);
> inc_lruvec_page_state(page, NR_PAGETABLE);
> return true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pgtable_pmd_page_dtor(struct page *page)
>{
> pmd_ptlock_free(page);
> __ClearPageTable(page);
> dec_lruvec_page_state(page, NR_PAGETABLE);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pud_lockptr(struct mm_struct *mm, pud_t *pud)
>{
> return &mm->page_table_lock;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) spinlock_t *pud_lock(struct mm_struct *mm, pud_t *pud)
>{
> spinlock_t *ptl = pud_lockptr(mm, pud);
>
> spin_lock(ptl);
> return ptl;
>}
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pagecache_init(void);
>extern void free_initmem(void);
>
>
>
>
>
>
>
>extern unsigned long free_reserved_area(void *start, void *end,
>     int poison, const char *s);
>
>extern void adjust_managed_page_count(struct page *page, long count);
>extern void mem_init_print_info(void);
>
>extern void reserve_bootmem_region(phys_addr_t start, phys_addr_t end);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void free_reserved_page(struct page *page)
>{
> ClearPageReserved(page);
> init_page_count(page);
> __free_pages((page), 0);
> adjust_managed_page_count(page, 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mark_page_reserved(struct page *page)
>{
> SetPageReserved(page);
> adjust_managed_page_count(page, -1);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long free_initmem_default(int poison)
>{
> extern char __init_begin[], __init_end[];
>
> return free_reserved_area(&__init_begin, &__init_end,
>      poison, "unused kernel image (initmem)");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_num_physpages(void)
>{
> int nid;
> unsigned long phys_pages = 0;
>
> for (((nid)) = __first_node(&(node_states[N_ONLINE])); ((nid)) < (1 << 10); ((nid)) = __next_node((((nid))), &((node_states[N_ONLINE]))))
>  phys_pages += ((node_data[nid])->node_present_pages);
>
> return phys_pages;
>}
># 2374 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>void free_area_init(unsigned long *max_zone_pfn);
>unsigned long node_map_pfn_alignment(void);
>unsigned long __absent_pages_in_range(int nid, unsigned long start_pfn,
>      unsigned long end_pfn);
>extern unsigned long absent_pages_in_range(unsigned long start_pfn,
>      unsigned long end_pfn);
>extern void get_pfn_range_for_nid(unsigned int nid,
>   unsigned long *start_pfn, unsigned long *end_pfn);
>extern unsigned long find_min_pfn_with_active_regions(void);
># 2391 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern int __attribute__((__section__(".meminit.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) early_pfn_to_nid(unsigned long pfn);
>
>
>extern void set_dma_reserve(unsigned long new_dma_reserve);
>extern void memmap_init_range(unsigned long, int, unsigned long,
>  unsigned long, unsigned long, enum meminit_context,
>  struct vmem_altmap *, int migratetype);
>extern void setup_per_zone_wmarks(void);
>extern int __attribute__((__section__(".meminit.text"))) __attribute__((__cold__)) __attribute__((no_instrument_function)) init_per_zone_wmark_min(void);
>extern void mem_init(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) mmap_init(void);
>extern void show_mem(unsigned int flags, nodemask_t *nodemask);
>extern long si_mem_available(void);
>extern void si_meminfo(struct sysinfo * val);
>extern void si_meminfo_node(struct sysinfo *val, int nid);
>
>
>
>
>extern __attribute__((__format__(printf, 3, 4)))
>void warn_alloc(gfp_t gfp_mask, nodemask_t *nodemask, const char *fmt, ...);
>
>extern void setup_per_cpu_pageset(void);
>
>
>extern int min_free_kbytes;
>extern int watermark_boost_factor;
>extern int watermark_scale_factor;
>extern bool arch_has_descending_max_zone_pfns(void);
>
>
>extern atomic_long_t mmap_pages_allocated;
>extern int nommu_shrink_inode_mappings(struct inode *, size_t, size_t);
>
>
>void vma_interval_tree_insert(struct vm_area_struct *node,
>         struct rb_root_cached *root);
>void vma_interval_tree_insert_after(struct vm_area_struct *node,
>        struct vm_area_struct *prev,
>        struct rb_root_cached *root);
>void vma_interval_tree_remove(struct vm_area_struct *node,
>         struct rb_root_cached *root);
>struct vm_area_struct *vma_interval_tree_iter_first(struct rb_root_cached *root,
>    unsigned long start, unsigned long last);
>struct vm_area_struct *vma_interval_tree_iter_next(struct vm_area_struct *node,
>    unsigned long start, unsigned long last);
>
>
>
>
>
>void anon_vma_interval_tree_insert(struct anon_vma_chain *node,
>       struct rb_root_cached *root);
>void anon_vma_interval_tree_remove(struct anon_vma_chain *node,
>       struct rb_root_cached *root);
>struct anon_vma_chain *
>anon_vma_interval_tree_iter_first(struct rb_root_cached *root,
>      unsigned long start, unsigned long last);
>struct anon_vma_chain *anon_vma_interval_tree_iter_next(
> struct anon_vma_chain *node, unsigned long start, unsigned long last);
># 2460 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern int __vm_enough_memory(struct mm_struct *mm, long pages, int cap_sys_admin);
>extern int __vma_adjust(struct vm_area_struct *vma, unsigned long start,
> unsigned long end, unsigned long pgoff, struct vm_area_struct *insert,
> struct vm_area_struct *expand);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vma_adjust(struct vm_area_struct *vma, unsigned long start,
> unsigned long end, unsigned long pgoff, struct vm_area_struct *insert)
>{
> return __vma_adjust(vma, start, end, pgoff, insert, ((void *)0));
>}
>extern struct vm_area_struct *vma_merge(struct mm_struct *,
> struct vm_area_struct *prev, unsigned long addr, unsigned long end,
> unsigned long vm_flags, struct anon_vma *, struct file *, unsigned long,
> struct mempolicy *, struct vm_userfaultfd_ctx);
>extern struct anon_vma *find_mergeable_anon_vma(struct vm_area_struct *);
>extern int __split_vma(struct mm_struct *, struct vm_area_struct *,
> unsigned long addr, int new_below);
>extern int split_vma(struct mm_struct *, struct vm_area_struct *,
> unsigned long addr, int new_below);
>extern int insert_vm_struct(struct mm_struct *, struct vm_area_struct *);
>extern void __vma_link_rb(struct mm_struct *, struct vm_area_struct *,
> struct rb_node **, struct rb_node *);
>extern void unlink_file_vma(struct vm_area_struct *);
>extern struct vm_area_struct *copy_vma(struct vm_area_struct **,
> unsigned long addr, unsigned long len, unsigned long pgoff,
> bool *need_rmap_locks);
>extern void exit_mmap(struct mm_struct *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int check_data_rlimit(unsigned long rlim,
>        unsigned long new,
>        unsigned long start,
>        unsigned long end_data,
>        unsigned long start_data)
>{
> if (rlim < (~0UL)) {
>  if (((new - start) + (end_data - start_data)) > rlim)
>   return -28;
> }
>
> return 0;
>}
>
>extern int mm_take_all_locks(struct mm_struct *mm);
>extern void mm_drop_all_locks(struct mm_struct *mm);
>
>extern void set_mm_exe_file(struct mm_struct *mm, struct file *new_exe_file);
>extern struct file *get_mm_exe_file(struct mm_struct *mm);
>extern struct file *get_task_exe_file(struct task_struct *task);
>
>extern bool may_expand_vm(struct mm_struct *, vm_flags_t, unsigned long npages);
>extern void vm_stat_account(struct mm_struct *, vm_flags_t, long npages);
>
>extern bool vma_is_special_mapping(const struct vm_area_struct *vma,
>       const struct vm_special_mapping *sm);
>extern struct vm_area_struct *_install_special_mapping(struct mm_struct *mm,
>       unsigned long addr, unsigned long len,
>       unsigned long flags,
>       const struct vm_special_mapping *spec);
>
>extern int install_special_mapping(struct mm_struct *mm,
>       unsigned long addr, unsigned long len,
>       unsigned long flags, struct page **pages);
>
>unsigned long randomize_stack_top(unsigned long stack_top);
>
>extern unsigned long get_unmapped_area(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
>
>extern unsigned long mmap_region(struct file *file, unsigned long addr,
> unsigned long len, vm_flags_t vm_flags, unsigned long pgoff,
> struct list_head *uf);
>extern unsigned long do_mmap(struct file *file, unsigned long addr,
> unsigned long len, unsigned long prot, unsigned long flags,
> unsigned long pgoff, unsigned long *populate, struct list_head *uf);
>extern int __do_munmap(struct mm_struct *, unsigned long, size_t,
>         struct list_head *uf, bool downgrade);
>extern int do_munmap(struct mm_struct *, unsigned long, size_t,
>       struct list_head *uf);
>extern int do_madvise(struct mm_struct *mm, unsigned long start, size_t len_in, int behavior);
>
>
>extern int __mm_populate(unsigned long addr, unsigned long len,
>    int ignore_errors);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mm_populate(unsigned long addr, unsigned long len)
>{
>
> (void) __mm_populate(addr, len, 1);
>}
>
>
>
>
>
>extern int __attribute__((__warn_unused_result__)) vm_brk(unsigned long, unsigned long);
>extern int __attribute__((__warn_unused_result__)) vm_brk_flags(unsigned long, unsigned long, unsigned long);
>extern int vm_munmap(unsigned long, size_t);
>extern unsigned long __attribute__((__warn_unused_result__)) vm_mmap(struct file *, unsigned long,
>        unsigned long, unsigned long,
>        unsigned long, unsigned long);
>
>struct vm_unmapped_area_info {
>
> unsigned long flags;
> unsigned long length;
> unsigned long low_limit;
> unsigned long high_limit;
> unsigned long align_mask;
> unsigned long align_offset;
>};
>
>extern unsigned long vm_unmapped_area(struct vm_unmapped_area_info *info);
>
>
>extern void truncate_inode_pages(struct address_space *, loff_t);
>extern void truncate_inode_pages_range(struct address_space *,
>           loff_t lstart, loff_t lend);
>extern void truncate_inode_pages_final(struct address_space *);
>
>
>extern vm_fault_t filemap_fault(struct vm_fault *vmf);
>extern vm_fault_t filemap_map_pages(struct vm_fault *vmf,
>  unsigned long start_pgoff, unsigned long end_pgoff);
>extern vm_fault_t filemap_page_mkwrite(struct vm_fault *vmf);
>
>
>int __attribute__((__warn_unused_result__)) write_one_page(struct page *page);
>void task_dirty_inc(struct task_struct *tsk);
>
>extern unsigned long stack_guard_gap;
>
>extern int expand_stack(struct vm_area_struct *vma, unsigned long address);
>
>
>extern int expand_downwards(struct vm_area_struct *vma,
>  unsigned long address);
>
>
>
>
>
>
>
>extern struct vm_area_struct * find_vma(struct mm_struct * mm, unsigned long addr);
>extern struct vm_area_struct * find_vma_prev(struct mm_struct * mm, unsigned long addr,
>          struct vm_area_struct **pprev);
># 2613 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct vm_area_struct *find_vma_intersection(struct mm_struct *mm,
>          unsigned long start_addr,
>          unsigned long end_addr)
>{
> struct vm_area_struct *vma = find_vma(mm, start_addr);
>
> if (vma && end_addr <= vma->vm_start)
>  vma = ((void *)0);
> return vma;
>}
># 2632 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct vm_area_struct *vma_lookup(struct mm_struct *mm, unsigned long addr)
>{
> struct vm_area_struct *vma = find_vma(mm, addr);
>
> if (vma && addr < vma->vm_start)
>  vma = ((void *)0);
>
> return vma;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long vm_start_gap(struct vm_area_struct *vma)
>{
> unsigned long vm_start = vma->vm_start;
>
> if (vma->vm_flags & 0x00000100) {
>  vm_start -= stack_guard_gap;
>  if (vm_start > vma->vm_start)
>   vm_start = 0;
> }
> return vm_start;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long vm_end_gap(struct vm_area_struct *vma)
>{
> unsigned long vm_end = vma->vm_end;
>
> if (vma->vm_flags & 0x00000000) {
>  vm_end += stack_guard_gap;
>  if (vm_end < vma->vm_end)
>   vm_end = -((1UL) << 12);
> }
> return vm_end;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long vma_pages(struct vm_area_struct *vma)
>{
> return (vma->vm_end - vma->vm_start) >> 12;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct vm_area_struct *find_exact_vma(struct mm_struct *mm,
>    unsigned long vm_start, unsigned long vm_end)
>{
> struct vm_area_struct *vma = find_vma(mm, vm_start);
>
> if (vma && (vma->vm_start != vm_start || vma->vm_end != vm_end))
>  vma = ((void *)0);
>
> return vma;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool range_in_vma(struct vm_area_struct *vma,
>    unsigned long start, unsigned long end)
>{
> return (vma && vma->vm_start <= start && end <= vma->vm_end);
>}
>
>
>pgprot_t vm_get_page_prot(unsigned long vm_flags);
>void vma_set_page_prot(struct vm_area_struct *vma);
># 2704 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>void vma_set_file(struct vm_area_struct *vma, struct file *file);
>
>
>unsigned long change_prot_numa(struct vm_area_struct *vma,
>   unsigned long start, unsigned long end);
>
>
>struct vm_area_struct *find_extend_vma(struct mm_struct *, unsigned long addr);
>int remap_pfn_range(struct vm_area_struct *, unsigned long addr,
>   unsigned long pfn, unsigned long size, pgprot_t);
>int remap_pfn_range_notrack(struct vm_area_struct *vma, unsigned long addr,
>  unsigned long pfn, unsigned long size, pgprot_t prot);
>int vm_insert_page(struct vm_area_struct *, unsigned long addr, struct page *);
>int vm_insert_pages(struct vm_area_struct *vma, unsigned long addr,
>   struct page **pages, unsigned long *num);
>int vm_map_pages(struct vm_area_struct *vma, struct page **pages,
>    unsigned long num);
>int vm_map_pages_zero(struct vm_area_struct *vma, struct page **pages,
>    unsigned long num);
>vm_fault_t vmf_insert_pfn(struct vm_area_struct *vma, unsigned long addr,
>   unsigned long pfn);
>vm_fault_t vmf_insert_pfn_prot(struct vm_area_struct *vma, unsigned long addr,
>   unsigned long pfn, pgprot_t pgprot);
>vm_fault_t vmf_insert_mixed(struct vm_area_struct *vma, unsigned long addr,
>   pfn_t pfn);
>vm_fault_t vmf_insert_mixed_prot(struct vm_area_struct *vma, unsigned long addr,
>   pfn_t pfn, pgprot_t pgprot);
>vm_fault_t vmf_insert_mixed_mkwrite(struct vm_area_struct *vma,
>  unsigned long addr, pfn_t pfn);
>int vm_iomap_memory(struct vm_area_struct *vma, phys_addr_t start, unsigned long len);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) vm_fault_t vmf_insert_page(struct vm_area_struct *vma,
>    unsigned long addr, struct page *page)
>{
> int err = vm_insert_page(vma, addr, page);
>
> if (err == -12)
>  return VM_FAULT_OOM;
> if (err < 0 && err != -16)
>  return VM_FAULT_SIGBUS;
>
> return VM_FAULT_NOPAGE;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int io_remap_pfn_range(struct vm_area_struct *vma,
>         unsigned long addr, unsigned long pfn,
>         unsigned long size, pgprot_t prot)
>{
> return remap_pfn_range(vma, addr, pfn, size, ((pgprot_t) { (cc_mkdec(((prot).pgprot))) } ));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) vm_fault_t vmf_error(int err)
>{
> if (err == -12)
>  return VM_FAULT_OOM;
> return VM_FAULT_SIGBUS;
>}
>
>struct page *follow_page(struct vm_area_struct *vma, unsigned long address,
>    unsigned int foll_flags);
># 2844 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vm_fault_to_errno(vm_fault_t vm_fault, int foll_flags)
>{
> if (vm_fault & VM_FAULT_OOM)
>  return -12;
> if (vm_fault & (VM_FAULT_HWPOISON | VM_FAULT_HWPOISON_LARGE))
>  return (foll_flags & 0x100) ? -133 : -14;
> if (vm_fault & (VM_FAULT_SIGBUS | VM_FAULT_SIGSEGV))
>  return -14;
> return 0;
>}
>
>typedef int (*pte_fn_t)(pte_t *pte, unsigned long addr, void *data);
>extern int apply_to_page_range(struct mm_struct *mm, unsigned long address,
>          unsigned long size, pte_fn_t fn, void *data);
>extern int apply_to_existing_page_range(struct mm_struct *mm,
>       unsigned long address, unsigned long size,
>       pte_fn_t fn, void *data);
>
>extern void init_mem_debugging_and_hardening(void);
># 2891 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_poisoning_enabled(void) { return false; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_poisoning_enabled_static(void) { return false; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __kernel_poison_pages(struct page *page, int nunmpages) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kernel_poison_pages(struct page *page, int numpages) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kernel_unpoison_pages(struct page *page, int numpages) { }
>
>
>extern struct static_key_false init_on_alloc;
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool want_init_on_alloc(gfp_t flags)
>{
> if ((0 ? ({ bool branch; if (__builtin_types_compatible_p(typeof(*&init_on_alloc), struct static_key_true)) branch = !arch_static_branch(&(&init_on_alloc)->key, true); else if (__builtin_types_compatible_p(typeof(*&init_on_alloc), struct static_key_false)) branch = !arch_static_branch_jump(&(&init_on_alloc)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }) : ({ bool branch; if (__builtin_types_compatible_p(typeof(*&init_on_alloc), struct static_key_true)) branch = arch_static_branch_jump(&(&init_on_alloc)->key, false); else if (__builtin_types_compatible_p(typeof(*&init_on_alloc), struct static_key_false)) branch = arch_static_branch(&(&init_on_alloc)->key, false); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 0); }))
>                   )
>  return true;
> return flags & (( gfp_t)0x100u);
>}
>
>extern struct static_key_false init_on_free;
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool want_init_on_free(void)
>{
> return (0 ? ({ bool branch; if (__builtin_types_compatible_p(typeof(*&init_on_free), struct static_key_true)) branch = !arch_static_branch(&(&init_on_free)->key, true); else if (__builtin_types_compatible_p(typeof(*&init_on_free), struct static_key_false)) branch = !arch_static_branch_jump(&(&init_on_free)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }) : ({ bool branch; if (__builtin_types_compatible_p(typeof(*&init_on_free), struct static_key_true)) branch = arch_static_branch_jump(&(&init_on_free)->key, false); else if (__builtin_types_compatible_p(typeof(*&init_on_free), struct static_key_false)) branch = arch_static_branch(&(&init_on_free)->key, false); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 0); }))
>                     ;
>}
>
>extern bool _debug_pagealloc_enabled_early;
>extern struct static_key_false _debug_pagealloc_enabled;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool debug_pagealloc_enabled(void)
>{
> return 1 &&
>  _debug_pagealloc_enabled_early;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool debug_pagealloc_enabled_static(void)
>{
> if (!1)
>  return false;
>
> return ({ bool branch; if (__builtin_types_compatible_p(typeof(*&_debug_pagealloc_enabled), struct static_key_true)) branch = arch_static_branch_jump(&(&_debug_pagealloc_enabled)->key, false); else if (__builtin_types_compatible_p(typeof(*&_debug_pagealloc_enabled), struct static_key_false)) branch = arch_static_branch(&(&_debug_pagealloc_enabled)->key, false); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 0); });
>}
>
>
>
>
>
>
>extern void __kernel_map_pages(struct page *page, int numpages, int enable);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_pagealloc_map_pages(struct page *page, int numpages)
>{
> if (debug_pagealloc_enabled_static())
>  __kernel_map_pages(page, numpages, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_pagealloc_unmap_pages(struct page *page, int numpages)
>{
> if (debug_pagealloc_enabled_static())
>  __kernel_map_pages(page, numpages, 0);
>}
>
>
>
>
>
>
>extern struct vm_area_struct *get_gate_vma(struct mm_struct *mm);
>extern int in_gate_area_no_mm(unsigned long addr);
>extern int in_gate_area(struct mm_struct *mm, unsigned long addr);
># 2974 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>extern bool process_shares_mm(struct task_struct *p, struct mm_struct *mm);
>
>
>extern int sysctl_drop_caches;
>int drop_caches_sysctl_handler(struct ctl_table *, int, void *, size_t *,
>  loff_t *);
>
>
>void drop_slab(void);
>void drop_slab_node(int nid);
>
>
>
>
>extern int randomize_va_space;
>
>
>const char * arch_vma_name(struct vm_area_struct *vma);
>
>void print_vma_addr(char *prefix, unsigned long rip);
>
>
>
>
>
>
>int vmemmap_remap_free(unsigned long start, unsigned long end,
>         unsigned long reuse);
>int vmemmap_remap_alloc(unsigned long start, unsigned long end,
>   unsigned long reuse, gfp_t gfp_mask);
>
>void *sparse_buffer_alloc(unsigned long size);
>struct page * __populate_section_memmap(unsigned long pfn,
>  unsigned long nr_pages, int nid, struct vmem_altmap *altmap);
>pgd_t *vmemmap_pgd_populate(unsigned long addr, int node);
>p4d_t *vmemmap_p4d_populate(pgd_t *pgd, unsigned long addr, int node);
>pud_t *vmemmap_pud_populate(p4d_t *p4d, unsigned long addr, int node);
>pmd_t *vmemmap_pmd_populate(pud_t *pud, unsigned long addr, int node);
>pte_t *vmemmap_pte_populate(pmd_t *pmd, unsigned long addr, int node,
>       struct vmem_altmap *altmap);
>void *vmemmap_alloc_block(unsigned long size, int node);
>struct vmem_altmap;
>void *vmemmap_alloc_block_buf(unsigned long size, int node,
>         struct vmem_altmap *altmap);
>void vmemmap_verify(pte_t *, int, unsigned long, unsigned long);
>int vmemmap_populate_basepages(unsigned long start, unsigned long end,
>          int node, struct vmem_altmap *altmap);
>int vmemmap_populate(unsigned long start, unsigned long end, int node,
>  struct vmem_altmap *altmap);
>void vmemmap_populate_print_last(void);
>
>void vmemmap_free(unsigned long start, unsigned long end,
>  struct vmem_altmap *altmap);
>
>void register_page_bootmem_memmap(unsigned long section_nr, struct page *map,
>      unsigned long nr_pages);
>
>enum mf_flags {
> MF_COUNT_INCREASED = 1 << 0,
> MF_ACTION_REQUIRED = 1 << 1,
> MF_MUST_KILL = 1 << 2,
> MF_SOFT_OFFLINE = 1 << 3,
>};
>extern int memory_failure(unsigned long pfn, int flags);
>extern void memory_failure_queue(unsigned long pfn, int flags);
>extern void memory_failure_queue_kick(int cpu);
>extern int unpoison_memory(unsigned long pfn);
>extern int sysctl_memory_failure_early_kill;
>extern int sysctl_memory_failure_recovery;
>extern void shake_page(struct page *p, int access);
>extern atomic_long_t num_poisoned_pages __attribute__((__section__(".data..read_mostly")));
>extern int soft_offline_page(unsigned long pfn, int flags);
>
>
>
>
>
>enum mf_result {
> MF_IGNORED,
> MF_FAILED,
> MF_DELAYED,
> MF_RECOVERED,
>};
>
>enum mf_action_page_type {
> MF_MSG_KERNEL,
> MF_MSG_KERNEL_HIGH_ORDER,
> MF_MSG_SLAB,
> MF_MSG_DIFFERENT_COMPOUND,
> MF_MSG_POISONED_HUGE,
> MF_MSG_HUGE,
> MF_MSG_FREE_HUGE,
> MF_MSG_NON_PMD_HUGE,
> MF_MSG_UNMAP_FAILED,
> MF_MSG_DIRTY_SWAPCACHE,
> MF_MSG_CLEAN_SWAPCACHE,
> MF_MSG_DIRTY_MLOCKED_LRU,
> MF_MSG_CLEAN_MLOCKED_LRU,
> MF_MSG_DIRTY_UNEVICTABLE_LRU,
> MF_MSG_CLEAN_UNEVICTABLE_LRU,
> MF_MSG_DIRTY_LRU,
> MF_MSG_CLEAN_LRU,
> MF_MSG_TRUNCATED_LRU,
> MF_MSG_BUDDY,
> MF_MSG_BUDDY_2ND,
> MF_MSG_DAX,
> MF_MSG_UNSPLIT_THP,
> MF_MSG_UNKNOWN,
>};
>
>
>extern void clear_huge_page(struct page *page,
>       unsigned long addr_hint,
>       unsigned int pages_per_huge_page);
>extern void copy_user_huge_page(struct page *dst, struct page *src,
>    unsigned long addr_hint,
>    struct vm_area_struct *vma,
>    unsigned int pages_per_huge_page);
>extern long copy_huge_page_from_user(struct page *dst_page,
>    const void *usr_src,
>    unsigned int pages_per_huge_page,
>    bool allow_pagefault);
># 3107 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vma_is_special_huge(const struct vm_area_struct *vma)
>{
> return vma_is_dax(vma) || (vma->vm_file &&
>       (vma->vm_flags & (0x00000400 | 0x10000000)));
>}
>
>
>
>
>extern unsigned int _debug_guardpage_minorder;
>extern struct static_key_false _debug_guardpage_enabled;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int debug_guardpage_minorder(void)
>{
> return _debug_guardpage_minorder;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool debug_guardpage_enabled(void)
>{
> return ({ bool branch; if (__builtin_types_compatible_p(typeof(*&_debug_guardpage_enabled), struct static_key_true)) branch = arch_static_branch_jump(&(&_debug_guardpage_enabled)->key, false); else if (__builtin_types_compatible_p(typeof(*&_debug_guardpage_enabled), struct static_key_false)) branch = arch_static_branch(&(&_debug_guardpage_enabled)->key, false); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_is_guard(struct page *page)
>{
> if (!debug_guardpage_enabled())
>  return false;
>
> return PageGuard(page);
>}
>
>
>
>
>
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) setup_nr_node_ids(void);
>
>
>
>
>extern int memcmp_pages(struct page *page1, struct page *page2);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pages_identical(struct page *page1, struct page *page2)
>{
> return !memcmp_pages(page1, page2);
>}
>
>
>unsigned long clean_record_shared_mapping_range(struct address_space *mapping,
>      unsigned long first_index, unsigned long nr,
>      unsigned long bitmap_pgoff,
>      unsigned long *bitmap,
>      unsigned long *start,
>      unsigned long *end);
>
>unsigned long wp_shared_mapping_range(struct address_space *mapping,
>          unsigned long first_index, unsigned long nr);
>
>
>extern int sysctl_nr_trim_pages;
>
>
>void mem_dump_obj(void *object);
># 3183 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int seal_check_future_write(int seals, struct vm_area_struct *vma)
>{
> if (seals & 0x0010) {
>
>
>
>
>  if ((vma->vm_flags & 0x00000008) && (vma->vm_flags & 0x00000002))
>   return -1;
># 3200 "/usr/src/linux-5.14.21-150500.53/include/linux/mm.h"
>  if (vma->vm_flags & 0x00000008)
>   vma->vm_flags &= ~(0x00000020);
> }
>
> return 0;
>}
># 18 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-pgprot.h" 2
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t pgprot_noncached_weak(pgprot_t old_prot)
>    {
>        pgprot_t new_prot = old_prot;
>        if (boot_cpu_data.x86 > 3)
>            new_prot = ((pgprot_t) { (((old_prot).pgprot) | (((pteval_t)(1)) << 4)) } );
>        return new_prot;
>    }
># 39 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-pgprot.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t pgprot_modify_writecombine(pgprot_t old_prot)
>    {
>        pgprot_t new_prot = old_prot;
>        ((new_prot).pgprot) &= ~((((pteval_t)(1)) << 7) | (((pteval_t)(1)) << 4) | (((pteval_t)(1)) << 3));
>        new_prot = ((pgprot_t) { (((new_prot).pgprot) | (((pteval_t)(1)) << 3)) } );
>        return new_prot;
>    }
># 21 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h" 1
># 26 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h"
># 1 "./include/generated/uapi/linux/version.h" 1
># 27 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h" 2
># 103 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h"
>        static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long NV_GET_USER_PAGES(unsigned long start,
>                                             unsigned long nr_pages,
>                                             int write,
>                                             int force,
>                                             struct page **pages,
>                                             struct vm_area_struct **vmas)
>        {
>            unsigned int flags = 0;
>
>            if (write)
>                flags |= 0x01;
>            if (force)
>                flags |= 0x10;
>
>            return get_user_pages(start, nr_pages, flags, pages, vmas);
>        }
># 178 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h"
>        static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long NV_GET_USER_PAGES_REMOTE(struct task_struct *tsk,
>                                                    struct mm_struct *mm,
>                                                    unsigned long start,
>                                                    unsigned long nr_pages,
>                                                    int write,
>                                                    int force,
>                                                    struct page **pages,
>                                                    struct vm_area_struct **vmas)
>        {
>            unsigned int flags = 0;
>
>            if (write)
>                flags |= 0x01;
>            if (force)
>                flags |= 0x10;
>
>
>
>
>
>
>               return get_user_pages_remote(mm, start, nr_pages, flags,
>                                            pages, vmas, ((void *)0));
># 210 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h"
>        }
># 262 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-mm.h"
>    static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long nv_page_fault_va(struct vm_fault *vmf)
>    {
>
>        return vmf->address;
>
>
>
>    }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_mmap_read_lock(struct mm_struct *mm)
>{
>
>    mmap_read_lock(mm);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_mmap_read_unlock(struct mm_struct *mm)
>{
>
>    mmap_read_unlock(mm);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_mmap_write_lock(struct mm_struct *mm)
>{
>
>    mmap_write_lock(mm);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_mmap_write_unlock(struct mm_struct *mm)
>{
>
>    mmap_write_unlock(mm);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int nv_mm_rwsem_is_locked(struct mm_struct *mm)
>{
>
>    return rwsem_is_locked(&mm->mmap_lock);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct rw_semaphore *nv_mmap_get_lock(struct mm_struct *mm)
>{
>
>    return &mm->mmap_lock;
>
>
>
>}
># 22 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/os-interface.h" 1
># 23 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-timer.h" 1
># 31 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-timer.h"
>struct nv_timer
>{
>    struct timer_list kernel_timer;
>    void (*nv_timer_callback)(struct nv_timer *nv_timer);
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_timer_callback_typed_data(struct timer_list *timer)
>{
>    struct nv_timer *nv_timer =
>        ({ void *__mptr = (void *)(timer); do { extern void __compiletime_assert_251(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(timer)), typeof(((struct nv_timer *)0)->kernel_timer)) && !__builtin_types_compatible_p(typeof(*(timer)), typeof(void))))) __compiletime_assert_251(); } while (0); ((struct nv_timer *)(__mptr - __builtin_offsetof(struct nv_timer, kernel_timer))); });
>
>    nv_timer->nv_timer_callback(nv_timer);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_timer_callback_anon_data(unsigned long arg)
>{
>    struct nv_timer *nv_timer = (struct nv_timer *)arg;
>
>    nv_timer->nv_timer_callback(nv_timer);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_timer_setup(struct nv_timer *nv_timer,
>                                  void (*callback)(struct nv_timer *nv_timer))
>{
>    nv_timer->nv_timer_callback = callback;
>
>
>    init_timer_key(((&nv_timer->kernel_timer)), ((nv_timer_callback_typed_data)), ((0)), ((void *)0), ((void *)0));
>
>
>
>
>
>}
># 24 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
>
>
># 1 "./include/generated/autoconf.h" 1
># 30 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
>
>
>
># 1 "./include/generated/utsrelease.h" 1
># 37 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
>
>
>
># 1 "./include/generated/uapi/linux/version.h" 1
># 44 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/utsname.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/nsproxy.h" 1
>
>
>
>
>
>
>
>struct mnt_namespace;
>struct uts_namespace;
>struct ipc_namespace;
>struct pid_namespace;
>struct cgroup_namespace;
>struct fs_struct;
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/nsproxy.h"
>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 time_namespace *time_ns;
> struct time_namespace *time_ns_for_children;
> struct cgroup_namespace *cgroup_ns;
>};
>extern struct nsproxy init_nsproxy;
># 53 "/usr/src/linux-5.14.21-150500.53/include/linux/nsproxy.h"
>struct nsset {
> unsigned flags;
> struct nsproxy *nsproxy;
> struct fs_struct *fs;
> const struct cred *cred;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cred *nsset_cred(struct nsset *set)
>{
> if (set->flags & 0x10000000)
>  return (struct cred *)set->cred;
>
> return ((void *)0);
>}
># 94 "/usr/src/linux-5.14.21-150500.53/include/linux/nsproxy.h"
>int copy_namespaces(unsigned long flags, struct task_struct *tsk);
>void exit_task_namespaces(struct task_struct *tsk);
>void switch_task_namespaces(struct task_struct *tsk, struct nsproxy *new);
>void free_nsproxy(struct nsproxy *ns);
>int unshare_nsproxy_namespaces(unsigned long, struct nsproxy **,
> struct cred *, struct fs_struct *);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) nsproxy_cache_init(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_nsproxy(struct nsproxy *ns)
>{
> if (atomic_dec_and_test(&ns->count)) {
>  free_nsproxy(ns);
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void get_nsproxy(struct nsproxy *ns)
>{
> atomic_inc(&ns->count);
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/utsname.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ns_common.h" 1
>
>
>
>
>
>
>struct proc_ns_operations;
>
>struct ns_common {
> atomic_long_t stashed;
> const struct proc_ns_operations *ops;
> unsigned int inum;
> refcount_t count;
>};
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/utsname.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/utsname.h" 1
>
>
>
>
>
>
>struct oldold_utsname {
> char sysname[9];
> char nodename[9];
> char release[9];
> char version[9];
> char machine[9];
>};
>
>
>
>struct old_utsname {
> char sysname[65];
> char nodename[65];
> char release[65];
> char version[65];
> char machine[65];
>};
>
>struct new_utsname {
> char sysname[64 + 1];
> char nodename[64 + 1];
> char release[64 + 1];
> char version[64 + 1];
> char machine[64 + 1];
> char domainname[64 + 1];
>};
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/utsname.h" 2
>
>enum uts_proc {
> UTS_PROC_OSTYPE,
> UTS_PROC_OSRELEASE,
> UTS_PROC_VERSION,
> UTS_PROC_HOSTNAME,
> UTS_PROC_DOMAINNAME,
>};
>
>struct user_namespace;
>extern struct user_namespace init_user_ns;
>
>struct uts_namespace {
> struct new_utsname name;
> struct user_namespace *user_ns;
> struct ucounts *ucounts;
> struct ns_common ns;
>} __attribute__((__designated_init__));
>extern struct uts_namespace init_uts_ns;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void get_uts_ns(struct uts_namespace *ns)
>{
> refcount_inc(&ns->ns.count);
>}
>
>extern struct uts_namespace *copy_utsname(unsigned long flags,
> struct user_namespace *user_ns, struct uts_namespace *old_ns);
>extern void free_uts_ns(struct uts_namespace *ns);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_uts_ns(struct uts_namespace *ns)
>{
> if (refcount_dec_and_test(&ns->ns.count))
>  free_uts_ns(ns);
>}
>
>void uts_ns_init(void);
># 72 "/usr/src/linux-5.14.21-150500.53/include/linux/utsname.h"
>extern void uts_proc_notify(enum uts_proc proc);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct new_utsname *utsname(void)
>{
> return &get_current()->nsproxy->uts_ns->name;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct new_utsname *init_utsname(void)
>{
> return &init_uts_ns.name;
>}
>
>extern struct rw_semaphore uts_sem;
># 45 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 65 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/buildid.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/buildid.h"
>int build_id_parse(struct vm_area_struct *vma, unsigned char *build_id,
>     __u32 *size);
>int build_id_parse_buf(const void *buf, unsigned char *build_id, u32 buf_size);
>
>
>extern unsigned char vmlinux_build_id[20];
>void init_vmlinux_build_id(void);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kmod.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/kmod.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/umh.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/umh.h"
>struct cred;
>struct file;
>
>
>
>
>
>
>struct subprocess_info {
> struct work_struct work;
> struct completion *complete;
> const char *path;
> char **argv;
> char **envp;
> int wait;
> int retval;
> int (*init)(struct subprocess_info *info, struct cred *new);
> void (*cleanup)(struct subprocess_info *info);
> void *data;
>} __attribute__((__designated_init__));
>
>extern int
>call_usermodehelper(const char *path, char **argv, char **envp, int wait);
>
>extern struct subprocess_info *
>call_usermodehelper_setup(const char *path, char **argv, char **envp,
>     gfp_t gfp_mask,
>     int (*init)(struct subprocess_info *info, struct cred *new),
>     void (*cleanup)(struct subprocess_info *), void *data);
>
>extern int
>call_usermodehelper_exec(struct subprocess_info *info, int wait);
>
>extern struct ctl_table usermodehelper_table[];
>
>enum umh_disable_depth {
> UMH_ENABLED = 0,
> UMH_FREEZING,
> UMH_DISABLED,
>};
>
>extern int __usermodehelper_disable(enum umh_disable_depth depth);
>extern void __usermodehelper_set_disable_depth(enum umh_disable_depth depth);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int usermodehelper_disable(void)
>{
> return __usermodehelper_disable(UMH_DISABLED);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void usermodehelper_enable(void)
>{
> __usermodehelper_set_disable_depth(UMH_ENABLED);
>}
>
>extern int usermodehelper_read_trylock(void);
>extern long usermodehelper_read_lock_wait(long timeout);
>extern void usermodehelper_read_unlock(void);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/kmod.h" 2
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/kmod.h"
>extern char modprobe_path[];
>
>
>extern __attribute__((__format__(printf, 2, 3)))
>int __request_module(bool wait, const char *name, ...);
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user_64.h" 1
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user_64.h" 2
># 51 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user_64.h"
>struct user_i387_struct {
> unsigned short cwd;
> unsigned short swd;
> unsigned short twd;
>
> unsigned short fop;
> __u64 rip;
> __u64 rdp;
> __u32 mxcsr;
> __u32 mxcsr_mask;
> __u32 st_space[32];
> __u32 xmm_space[64];
> __u32 padding[24];
>};
>
>
>
>
>struct user_regs_struct {
> unsigned long r15;
> unsigned long r14;
> unsigned long r13;
> unsigned long r12;
> unsigned long bp;
> unsigned long bx;
> unsigned long r11;
> unsigned long r10;
> unsigned long r9;
> unsigned long r8;
> unsigned long ax;
> unsigned long cx;
> unsigned long dx;
> unsigned long si;
> unsigned long di;
> unsigned long orig_ax;
> unsigned long ip;
> unsigned long cs;
> unsigned long flags;
> unsigned long sp;
> unsigned long ss;
> unsigned long fs_base;
> unsigned long gs_base;
> unsigned long ds;
> unsigned long es;
> unsigned long fs;
> unsigned long gs;
>};
>
>
>
>
>
>struct user {
>
>
>  struct user_regs_struct regs;
>
>  int u_fpvalid;
>
>  int pad0;
>  struct user_i387_struct i387;
>
>  unsigned long int u_tsize;
>  unsigned long int u_dsize;
>  unsigned long int u_ssize;
>  unsigned long start_code;
>  unsigned long start_stack;
>
>
>
>  long int signal;
>  int reserved;
>  int pad1;
>  unsigned long u_ar0;
>
>  struct user_i387_struct *u_fpstate;
>  unsigned long magic;
>  char u_comm[32];
>  unsigned long u_debugreg[8];
>  unsigned long error_code;
>  unsigned long fault_address;
>};
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user.h" 2
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user.h" 2
>
>struct user_ymmh_regs {
>
> __u32 ymmh_space[64];
>};
>
>struct user_xstate_header {
> __u64 xfeatures;
> __u64 reserved1[2];
> __u64 reserved2[5];
>};
># 54 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user.h"
>struct user_xstateregs {
> struct {
>  __u64 fpx_space[58];
>  __u64 xstate_fx_sw[6];
> } i387;
> struct user_xstate_header header;
> struct user_ymmh_regs ymmh;
>
>};
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fsgsbase.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/fsgsbase.h"
>extern unsigned long x86_fsbase_read_task(struct task_struct *task);
>extern unsigned long x86_gsbase_read_task(struct task_struct *task);
>extern void x86_fsbase_write_task(struct task_struct *task, unsigned long fsbase);
>extern void x86_gsbase_write_task(struct task_struct *task, unsigned long gsbase);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long rdfsbase(void)
>{
> unsigned long fsbase;
>
> asm volatile("rdfsbase %0" : "=r" (fsbase) :: "memory");
>
> return fsbase;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned long rdgsbase(void)
>{
> unsigned long gsbase;
>
> asm volatile("rdgsbase %0" : "=r" (gsbase) :: "memory");
>
> return gsbase;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void wrfsbase(unsigned long fsbase)
>{
> asm volatile("wrfsbase %0" :: "r" (fsbase) : "memory");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void wrgsbase(unsigned long gsbase)
>{
> asm volatile("wrgsbase %0" :: "r" (gsbase) : "memory");
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long x86_fsbase_read_cpu(void)
>{
> unsigned long fsbase;
>
> if ((__builtin_constant_p(( 9*32+ 0)) && ( (((( 9*32+ 0))>>5)==(0) && (1UL<<((( 9*32+ 0))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 9*32+ 0))>>5)==(1) && (1UL<<((( 9*32+ 0))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 9*32+ 0))>>5)==(2) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(3) && (1UL<<((( 9*32+ 0))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 9*32+ 0))>>5)==(4) && (1UL<<((( 9*32+ 0))&31) & (0) )) || (((( 9*32+ 0))>>5)==(5) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(6) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(7) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(8) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(9) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(10) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(11) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(12) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(13) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(14) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(15) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(16) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(17) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(18) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(19) && (1UL<<((( 9*32+ 0))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 9*32+ 0), (unsigned long *)((&boot_cpu_data)->x86_capability))))
>  fsbase = rdfsbase();
> else
>  do { fsbase = paravirt_read_msr(0xc0000100); } while (0);
>
> return fsbase;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void x86_fsbase_write_cpu(unsigned long fsbase)
>{
> if ((__builtin_constant_p(( 9*32+ 0)) && ( (((( 9*32+ 0))>>5)==(0) && (1UL<<((( 9*32+ 0))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 9*32+ 0))>>5)==(1) && (1UL<<((( 9*32+ 0))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 9*32+ 0))>>5)==(2) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(3) && (1UL<<((( 9*32+ 0))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 9*32+ 0))>>5)==(4) && (1UL<<((( 9*32+ 0))&31) & (0) )) || (((( 9*32+ 0))>>5)==(5) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(6) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(7) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(8) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(9) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(10) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(11) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(12) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(13) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(14) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(15) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(16) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(17) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(18) && (1UL<<((( 9*32+ 0))&31) & 0 )) || (((( 9*32+ 0))>>5)==(19) && (1UL<<((( 9*32+ 0))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 9*32+ 0), (unsigned long *)((&boot_cpu_data)->x86_capability))))
>  wrfsbase(fsbase);
> else
>  wrmsrl(0xc0000100, fsbase);
>}
>
>extern unsigned long x86_gsbase_read_cpu_inactive(void);
>extern void x86_gsbase_write_cpu_inactive(unsigned long gsbase);
>extern unsigned long x86_fsgsbase_read_task(struct task_struct *task,
>         unsigned short selector);
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h" 2
>
>typedef unsigned long elf_greg_t;
>
>
>typedef elf_greg_t elf_gregset_t[(sizeof(struct user_regs_struct) / sizeof(elf_greg_t))];
>
>typedef struct user_i387_struct elf_fpregset_t;
># 75 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vdso.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vdso.h"
>struct vdso_image {
> void *data;
> unsigned long size;
>
> unsigned long alt, alt_len;
> unsigned long extable_base, extable_len;
> const void *extable;
>
> long sym_vvar_start;
>
> long sym_vvar_page;
> long sym_pvclock_page;
> long sym_hvclock_page;
> long sym_timens_page;
> long sym_VDSO32_NOTE_MASK;
> long sym___kernel_sigreturn;
> long sym___kernel_rt_sigreturn;
> long sym___kernel_vsyscall;
> long sym_int80_landing_pad;
> long sym_vdso32_sigreturn_landing_pad;
> long sym_vdso32_rt_sigreturn_landing_pad;
>};
>
>
>extern const struct vdso_image vdso_image_64;
>
>
>
>
>
>
>
>extern const struct vdso_image vdso_image_32;
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) init_vdso_image(const struct vdso_image *image);
>
>extern int map_vdso_once(const struct vdso_image *image, unsigned long addr);
>
>extern bool fixup_vdso_exception(struct pt_regs *regs, int trapnr,
>     unsigned long error_code,
>     unsigned long fault_addr);
># 76 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h" 2
>
>
>extern unsigned int vdso64_enabled;
>
>
>extern unsigned int vdso32_enabled;
># 170 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void elf_common_init(struct thread_struct *t,
>       struct pt_regs *regs, const u16 ds)
>{
>
>                 regs->bx = regs->cx = regs->dx = 0;
> regs->si = regs->di = regs->bp = 0;
> regs->r8 = regs->r9 = regs->r10 = regs->r11 = 0;
> regs->r12 = regs->r13 = regs->r14 = regs->r15 = 0;
> t->fsbase = t->gsbase = 0;
> t->fsindex = t->gsindex = 0;
> t->ds = t->es = ds;
>}
>
>
>
>
>
>
>
>void compat_start_thread(struct pt_regs *regs, u32 new_ip, u32 new_sp, bool x32);
>
>
>
>void set_personality_ia32(bool);
># 239 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
>extern void set_personality_64bit(void);
>extern unsigned int sysctl_vsyscall32;
>extern int force_personality32;
># 262 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
>extern u32 elf_hwcap2;
># 307 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
>struct task_struct;
># 321 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mmap_is_ia32(void)
>{
> return 0 ||
>        (1 &&
>  test_ti_thread_flag(((struct thread_info *)get_current()), 29));
>}
>
>extern unsigned long task_size_32bit(void);
>extern unsigned long task_size_64bit(int full_addr_space);
>extern unsigned long get_mmap_base(int is_legacy);
>extern bool mmap_address_hint_valid(unsigned long addr, unsigned long len);
>extern unsigned long get_sigframe_size(void);
># 384 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/elf.h"
>struct linux_binprm;
>
>
>extern int arch_setup_additional_pages(struct linux_binprm *bprm,
>           int uses_interp);
>extern int compat_arch_setup_additional_pages(struct linux_binprm *bprm,
>           int uses_interp, bool x32);
>
>
>
>
>extern bool arch_syscall_is_vdso_sigreturn(struct pt_regs *regs);
>
>
>enum align_flags {
> ALIGN_VA_32 = ((((1UL))) << (0)),
> ALIGN_VA_64 = ((((1UL))) << (1)),
>};
>
>struct va_alignment {
> int flags;
> unsigned long mask;
> unsigned long bits;
>} __attribute__((__aligned__((1 << (6)))));
>
>extern struct va_alignment va_align;
>extern unsigned long align_vdso_addr(unsigned long);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf-em.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf.h" 2
>
>
>typedef __u32 Elf32_Addr;
>typedef __u16 Elf32_Half;
>typedef __u32 Elf32_Off;
>typedef __s32 Elf32_Sword;
>typedef __u32 Elf32_Word;
>
>
>typedef __u64 Elf64_Addr;
>typedef __u16 Elf64_Half;
>typedef __s16 Elf64_SHalf;
>typedef __u64 Elf64_Off;
>typedef __s32 Elf64_Sword;
>typedef __u32 Elf64_Word;
>typedef __u64 Elf64_Xword;
>typedef __s64 Elf64_Sxword;
># 139 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf.h"
>typedef struct dynamic{
>  Elf32_Sword d_tag;
>  union{
>    Elf32_Sword d_val;
>    Elf32_Addr d_ptr;
>  } d_un;
>} Elf32_Dyn;
>
>typedef struct {
>  Elf64_Sxword d_tag;
>  union {
>    Elf64_Xword d_val;
>    Elf64_Addr d_ptr;
>  } d_un;
>} Elf64_Dyn;
># 162 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf.h"
>typedef struct elf32_rel {
>  Elf32_Addr r_offset;
>  Elf32_Word r_info;
>} Elf32_Rel;
>
>typedef struct elf64_rel {
>  Elf64_Addr r_offset;
>  Elf64_Xword r_info;
>} Elf64_Rel;
>
>typedef struct elf32_rela{
>  Elf32_Addr r_offset;
>  Elf32_Word r_info;
>  Elf32_Sword r_addend;
>} Elf32_Rela;
>
>typedef struct elf64_rela {
>  Elf64_Addr r_offset;
>  Elf64_Xword r_info;
>  Elf64_Sxword r_addend;
>} Elf64_Rela;
>
>typedef struct elf32_sym{
>  Elf32_Word st_name;
>  Elf32_Addr st_value;
>  Elf32_Word st_size;
>  unsigned char st_info;
>  unsigned char st_other;
>  Elf32_Half st_shndx;
>} Elf32_Sym;
>
>typedef 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;
>} Elf64_Sym;
>
>
>
>
>typedef 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;
>} Elf32_Ehdr;
>
>typedef 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;
>} Elf64_Ehdr;
>
>
>
>
>
>
>
>typedef 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;
>} Elf32_Phdr;
>
>typedef 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;
>} Elf64_Phdr;
># 304 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf.h"
>typedef 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;
>} Elf32_Shdr;
>
>typedef 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;
>} Elf64_Shdr;
># 440 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/elf.h"
>typedef struct elf32_note {
>  Elf32_Word n_namesz;
>  Elf32_Word n_descsz;
>  Elf32_Word n_type;
>} Elf32_Nhdr;
>
>
>typedef struct elf64_note {
>  Elf64_Word n_namesz;
>  Elf64_Word n_descsz;
>  Elf64_Word n_type;
>} Elf64_Nhdr;
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h" 2
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h"
>extern Elf64_Dyn _DYNAMIC [];
># 65 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h"
>struct file;
>struct coredump_params;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int elf_coredump_extra_notes_size(void) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int elf_coredump_extra_notes_write(struct coredump_params *cprm) { return 0; }
># 81 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h"
>struct gnu_property {
> u32 pr_type;
> u32 pr_datasz;
>};
>
>struct arch_elf_state;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_parse_elf_property(u32 type, const void *data,
>       size_t datasz, bool compat,
>       struct arch_elf_state *arch)
>{
> return 0;
>}
># 104 "/usr/src/linux-5.14.21-150500.53/include/linux/elf.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_elf_adjust_prot(int prot,
>           const struct arch_elf_state *state,
>           bool has_interp, bool is_interp)
>{
> return prot;
>}
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>struct idr {
> struct xarray idr_rt;
> unsigned int idr_base;
> unsigned int idr_next;
>};
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int idr_get_cursor(const struct idr *idr)
>{
> return ({ do { extern void __compiletime_assert_252(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(idr->idr_next) == sizeof(char) || sizeof(idr->idr_next) == sizeof(short) || sizeof(idr->idr_next) == sizeof(int) || sizeof(idr->idr_next) == sizeof(long)) || sizeof(idr->idr_next) == sizeof(long long))) __compiletime_assert_252(); } while (0); (*(const volatile typeof( _Generic((idr->idr_next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (idr->idr_next))) *)&(idr->idr_next)); });
>}
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void idr_set_cursor(struct idr *idr, unsigned int val)
>{
> do { do { extern void __compiletime_assert_253(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(idr->idr_next) == sizeof(char) || sizeof(idr->idr_next) == sizeof(short) || sizeof(idr->idr_next) == sizeof(int) || sizeof(idr->idr_next) == sizeof(long)) || sizeof(idr->idr_next) == sizeof(long long))) __compiletime_assert_253(); } while (0); do { *(volatile typeof(idr->idr_next) *)&(idr->idr_next) = (val); } while (0); } while (0);
>}
># 112 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>void idr_preload(gfp_t gfp_mask);
>
>int idr_alloc(struct idr *, void *ptr, int start, int end, gfp_t);
>int __attribute__((__warn_unused_result__)) idr_alloc_u32(struct idr *, void *ptr, u32 *id,
>    unsigned long max, gfp_t);
>int idr_alloc_cyclic(struct idr *, void *ptr, int start, int end, gfp_t);
>void *idr_remove(struct idr *, unsigned long id);
>void *idr_find(const struct idr *, unsigned long id);
>int idr_for_each(const struct idr *,
>   int (*fn)(int id, void *p, void *data), void *data);
>void *idr_get_next(struct idr *, int *nextid);
>void *idr_get_next_ul(struct idr *, unsigned long *nextid);
>void *idr_replace(struct idr *, void *, unsigned long id);
>void idr_destroy(struct idr *);
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void idr_init_base(struct idr *idr, int base)
>{
> xa_init_flags(&idr->idr_rt, ((( gfp_t)4) | ( gfp_t) (1 << (((25 + 0)) + 0))));
> idr->idr_base = base;
> idr->idr_next = 0;
>}
># 149 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void idr_init(struct idr *idr)
>{
> idr_init_base(idr, 0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool idr_is_empty(const struct idr *idr)
>{
> return radix_tree_empty(&idr->idr_rt) &&
>  radix_tree_tagged(&idr->idr_rt, 0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void idr_preload_end(void)
>{
> do { do { ({ local_lock_t * __dummy; typeof(({ do { const void *__vpp_verify = (typeof((&radix_tree_preloads.lock) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long tcp_ptr__; asm volatile("add " "%%""gs"":" "%" "1" ", %0" : "=r" (tcp_ptr__) : "m" (this_cpu_off), "0" (&radix_tree_preloads.lock)); (typeof(*(&radix_tree_preloads.lock)) *)tcp_ptr__; }); })) __dummy2; (void)(&__dummy == &__dummy2); 1; }); } while (0); do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0); } while (0);
>}
># 240 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>struct ida_bitmap {
> unsigned long bitmap[(128 / sizeof(long))];
>};
>
>struct ida {
> struct xarray xa;
>};
># 255 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>int ida_alloc_range(struct ida *, unsigned int min, unsigned int max, gfp_t);
>void ida_free(struct ida *, unsigned int id);
>void ida_destroy(struct ida *ida);
># 271 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ida_alloc(struct ida *ida, gfp_t gfp)
>{
> return ida_alloc_range(ida, 0, ~0, gfp);
>}
># 289 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ida_alloc_min(struct ida *ida, unsigned int min, gfp_t gfp)
>{
> return ida_alloc_range(ida, min, ~0, gfp);
>}
># 307 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ida_alloc_max(struct ida *ida, unsigned int max, gfp_t gfp)
>{
> return ida_alloc_range(ida, 0, max, gfp);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ida_init(struct ida *ida)
>{
> xa_init_flags(&ida->xa, ((( gfp_t)XA_LOCK_IRQ) | ((( gfp_t)4U) | (( gfp_t)((1U << (25 + 0)) << ( unsigned)((( xa_mark_t)0U)))))));
>}
># 325 "/usr/src/linux-5.14.21-150500.53/include/linux/idr.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ida_is_empty(const struct ida *ida)
>{
> return xa_empty(&ida->xa);
>}
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h" 2
>
>
>
>
>
>
>struct file;
>struct dentry;
>struct iattr;
>struct seq_file;
>struct vm_area_struct;
>struct super_block;
>struct file_system_type;
>struct poll_table_struct;
>struct fs_context;
>
>struct kernfs_fs_context;
>struct kernfs_open_node;
>struct kernfs_iattrs;
>
>enum kernfs_node_type {
> KERNFS_DIR = 0x0001,
> KERNFS_FILE = 0x0002,
> KERNFS_LINK = 0x0004,
>};
>
>
>
>
>
>
>enum kernfs_node_flag {
> KERNFS_ACTIVATED = 0x0010,
> KERNFS_NS = 0x0020,
> KERNFS_HAS_SEQ_SHOW = 0x0040,
> KERNFS_HAS_MMAP = 0x0080,
> KERNFS_LOCKDEP = 0x0100,
> KERNFS_SUICIDAL = 0x0400,
> KERNFS_SUICIDED = 0x0800,
> KERNFS_EMPTY_DIR = 0x1000,
> KERNFS_HAS_RELEASE = 0x2000,
>};
>
>
>enum kernfs_root_flag {
>
>
>
>
>
>
> KERNFS_ROOT_CREATE_DEACTIVATED = 0x0001,
># 76 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
> KERNFS_ROOT_EXTRA_OPEN_PERM_CHECK = 0x0002,
>
>
>
>
>
> KERNFS_ROOT_SUPPORT_EXPORTOP = 0x0004,
>
>
>
>
> KERNFS_ROOT_SUPPORT_USER_XATTR = 0x0008,
>};
>
>
>struct kernfs_elem_dir {
> unsigned long subdirs;
>
> struct rb_root children;
>
>
>
>
>
> struct kernfs_root *root;
>};
>
>struct kernfs_elem_symlink {
> struct kernfs_node *target_kn;
>};
>
>struct kernfs_elem_attr {
> const struct kernfs_ops *ops;
> struct kernfs_open_node *open;
> loff_t size;
> struct kernfs_node *notify_next;
>};
># 123 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
>struct kernfs_node {
> atomic_t count;
> atomic_t active;
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
> 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;
>
>
>
>
>
> u64 id;
>
> unsigned short flags;
> umode_t mode;
> struct kernfs_iattrs *iattr;
>};
># 168 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
>struct kernfs_syscall_ops {
> int (*show_options)(struct seq_file *sf, struct kernfs_root *root);
>
> int (*mkdir)(struct kernfs_node *parent, const char *name,
>       umode_t mode);
> int (*rmdir)(struct kernfs_node *kn);
> int (*rename)(struct kernfs_node *kn, struct kernfs_node *new_parent,
>        const char *new_name);
> int (*show_path)(struct seq_file *sf, struct kernfs_node *kn,
>    struct kernfs_root *root);
>};
>
>struct kernfs_root {
>
> struct kernfs_node *kn;
> unsigned int flags;
>
>
> struct idr ino_idr;
> u32 last_id_lowbits;
> u32 id_highbits;
> struct kernfs_syscall_ops *syscall_ops;
>
>
> struct list_head supers;
>
> wait_queue_head_t deactivate_waitq;
>};
>
>struct kernfs_open_file {
>
> struct kernfs_node *kn;
> struct file *file;
> struct seq_file *seq_file;
> void *priv;
>
>
> struct mutex mutex;
> struct mutex prealloc_mutex;
> int event;
> struct list_head list;
> char *prealloc_buf;
>
> size_t atomic_write_len;
> bool mmapped:1;
> bool released:1;
> const struct vm_operations_struct *vm_ops;
>};
>
>struct kernfs_ops {
>
>
>
>
> int (*open)(struct kernfs_open_file *of);
> void (*release)(struct kernfs_open_file *of);
># 236 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
> int (*seq_show)(struct seq_file *sf, void *v);
>
> void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
> void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
> void (*seq_stop)(struct seq_file *sf, void *v);
>
> ssize_t (*read)(struct kernfs_open_file *of, char *buf, size_t bytes,
>   loff_t off);
># 252 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
> size_t atomic_write_len;
>
>
>
>
>
>
> bool prealloc;
> ssize_t (*write)(struct kernfs_open_file *of, char *buf, size_t bytes,
>    loff_t off);
>
> __poll_t (*poll)(struct kernfs_open_file *of,
>    struct poll_table_struct *pt);
>
> int (*mmap)(struct kernfs_open_file *of, struct vm_area_struct *vma);
>
>
>
>
>};
>
>
>
>
>struct kernfs_fs_context {
> struct kernfs_root *root;
> void *ns_tag;
> unsigned long magic;
>
>
> bool new_sb_created;
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) enum kernfs_node_type kernfs_type(struct kernfs_node *kn)
>{
> return kn->flags & 0x000f;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ino_t kernfs_id_ino(u64 id)
>{
>
> if (sizeof(ino_t) >= sizeof(u64))
>  return id;
> else
>  return (u32)id;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 kernfs_id_gen(u64 id)
>{
>
> if (sizeof(ino_t) >= sizeof(u64))
>  return 1;
> else
>  return id >> 32;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ino_t kernfs_ino(struct kernfs_node *kn)
>{
> return kernfs_id_ino(kn->id);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ino_t kernfs_gen(struct kernfs_node *kn)
>{
> return kernfs_id_gen(kn->id);
>}
># 328 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kernfs_enable_ns(struct kernfs_node *kn)
>{
> ({ int __ret_warn_on = !!(kernfs_type(kn) != KERNFS_DIR); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"), "i" (330), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("254" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "254" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> ({ int __ret_warn_on = !!(!(({ do { extern void __compiletime_assert_255(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((&kn->dir.children)->rb_node) == sizeof(char) || sizeof((&kn->dir.children)->rb_node) == sizeof(short) || sizeof((&kn->dir.children)->rb_node) == sizeof(int) || sizeof((&kn->dir.children)->rb_node) == sizeof(long)) || sizeof((&kn->dir.children)->rb_node) == sizeof(long long))) __compiletime_assert_255(); } while (0); (*(const volatile typeof( _Generic(((&kn->dir.children)->rb_node), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((&kn->dir.children)->rb_node))) *)&((&kn->dir.children)->rb_node)); }) == ((void *)0))); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"), "i" (331), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("256" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "256" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> kn->flags |= KERNFS_NS;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kernfs_ns_enabled(struct kernfs_node *kn)
>{
> return kn->flags & KERNFS_NS;
>}
>
>int kernfs_name(struct kernfs_node *kn, char *buf, size_t buflen);
>int kernfs_path_from_node(struct kernfs_node *root_kn, struct kernfs_node *kn,
>     char *buf, size_t buflen);
>void pr_cont_kernfs_name(struct kernfs_node *kn);
>void pr_cont_kernfs_path(struct kernfs_node *kn);
>struct kernfs_node *kernfs_get_parent(struct kernfs_node *kn);
>struct kernfs_node *kernfs_find_and_get_ns(struct kernfs_node *parent,
>        const char *name, const void *ns);
>struct kernfs_node *kernfs_walk_and_get_ns(struct kernfs_node *parent,
>        const char *path, const void *ns);
>void kernfs_get(struct kernfs_node *kn);
>void kernfs_put(struct kernfs_node *kn);
>
>struct kernfs_node *kernfs_node_from_dentry(struct dentry *dentry);
>struct kernfs_root *kernfs_root_from_sb(struct super_block *sb);
>struct inode *kernfs_get_inode(struct super_block *sb, struct kernfs_node *kn);
>
>struct dentry *kernfs_node_dentry(struct kernfs_node *kn,
>      struct super_block *sb);
>struct kernfs_root *kernfs_create_root(struct kernfs_syscall_ops *scops,
>           unsigned int flags, void *priv);
>void kernfs_destroy_root(struct kernfs_root *root);
>
>struct kernfs_node *kernfs_create_dir_ns(struct kernfs_node *parent,
>      const char *name, umode_t mode,
>      kuid_t uid, kgid_t gid,
>      void *priv, const void *ns);
>struct kernfs_node *kernfs_create_empty_dir(struct kernfs_node *parent,
>         const char *name);
>struct kernfs_node *__kernfs_create_file(struct kernfs_node *parent,
>      const char *name, umode_t mode,
>      kuid_t uid, kgid_t gid,
>      loff_t size,
>      const struct kernfs_ops *ops,
>      void *priv, const void *ns,
>      struct lock_class_key *key);
>struct kernfs_node *kernfs_create_link(struct kernfs_node *parent,
>           const char *name,
>           struct kernfs_node *target);
>void kernfs_activate(struct kernfs_node *kn);
>void kernfs_remove(struct kernfs_node *kn);
>void kernfs_break_active_protection(struct kernfs_node *kn);
>void kernfs_unbreak_active_protection(struct kernfs_node *kn);
>bool kernfs_remove_self(struct kernfs_node *kn);
>int kernfs_remove_by_name_ns(struct kernfs_node *parent, const char *name,
>        const void *ns);
>int kernfs_rename_ns(struct kernfs_node *kn, struct kernfs_node *new_parent,
>       const char *new_name, const void *new_ns);
>int kernfs_setattr(struct kernfs_node *kn, const struct iattr *iattr);
>__poll_t kernfs_generic_poll(struct kernfs_open_file *of,
>        struct poll_table_struct *pt);
>void kernfs_notify(struct kernfs_node *kn);
>
>int kernfs_xattr_get(struct kernfs_node *kn, const char *name,
>       void *value, size_t size);
>int kernfs_xattr_set(struct kernfs_node *kn, const char *name,
>       const void *value, size_t size, int flags);
>
>const void *kernfs_super_ns(struct super_block *sb);
>int kernfs_get_tree(struct fs_context *fc);
>void kernfs_free_fs_context(struct fs_context *fc);
>void kernfs_kill_sb(struct super_block *sb);
>
>void kernfs_init(void);
>
>struct kernfs_node *kernfs_find_and_get_node_by_id(struct kernfs_root *root,
>         u64 id);
># 540 "/usr/src/linux-5.14.21-150500.53/include/linux/kernfs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kernfs_path(struct kernfs_node *kn, char *buf, size_t buflen)
>{
> return kernfs_path_from_node(kn, ((void *)0), buf, buflen);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *
>kernfs_find_and_get(struct kernfs_node *kn, const char *name)
>{
> return kernfs_find_and_get_ns(kn, name, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *
>kernfs_walk_and_get(struct kernfs_node *kn, const char *path)
>{
> return kernfs_walk_and_get_ns(kn, path, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *
>kernfs_create_dir(struct kernfs_node *parent, const char *name, umode_t mode,
>    void *priv)
>{
> return kernfs_create_dir_ns(parent, name, mode,
>        (kuid_t){ 0 }, (kgid_t){ 0 },
>        priv, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *
>kernfs_create_file_ns(struct kernfs_node *parent, const char *name,
>        umode_t mode, kuid_t uid, kgid_t gid,
>        loff_t size, const struct kernfs_ops *ops,
>        void *priv, const void *ns)
>{
> struct lock_class_key *key = ((void *)0);
>
>
>
>
> return __kernfs_create_file(parent, name, mode, uid, gid,
>        size, ops, priv, ns, key);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *
>kernfs_create_file(struct kernfs_node *parent, const char *name, umode_t mode,
>     loff_t size, const struct kernfs_ops *ops, void *priv)
>{
> return kernfs_create_file_ns(parent, name, mode,
>         (kuid_t){ 0 }, (kgid_t){ 0 },
>         size, ops, priv, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kernfs_remove_by_name(struct kernfs_node *parent,
>     const char *name)
>{
> return kernfs_remove_by_name_ns(parent, name, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kernfs_rename(struct kernfs_node *kn,
>    struct kernfs_node *new_parent,
>    const char *new_name)
>{
> return kernfs_rename_ns(kn, new_parent, new_name, ((void *)0));
>}
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject_ns.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject_ns.h"
>struct sock;
>struct kobject;
>
>
>
>
>
>enum kobj_ns_type {
> KOBJ_NS_TYPE_NONE = 0,
> KOBJ_NS_TYPE_NET,
> KOBJ_NS_TYPES
>};
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject_ns.h"
>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 *sk);
> const void *(*initial_ns)(void);
> void (*drop_ns)(void *);
>};
>
>int kobj_ns_type_register(const struct kobj_ns_type_operations *ops);
>int kobj_ns_type_registered(enum kobj_ns_type type);
>const struct kobj_ns_type_operations *kobj_child_ns_ops(struct kobject *parent);
>const struct kobj_ns_type_operations *kobj_ns_ops(struct kobject *kobj);
>
>bool kobj_ns_current_may_mount(enum kobj_ns_type type);
>void *kobj_ns_grab_current(enum kobj_ns_type type);
>const void *kobj_ns_netlink(enum kobj_ns_type type, struct sock *sk);
>const void *kobj_ns_initial(enum kobj_ns_type type);
>void kobj_ns_drop(enum kobj_ns_type type, void *ns);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h" 2
>
>
>
>struct kobject;
>struct module;
>struct bin_attribute;
>enum kobj_ns_type;
>
>struct attribute {
> const char *name;
> umode_t mode;
>
>
>
>
>
>};
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h"
>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 *, int);
> struct attribute **attrs;
> struct bin_attribute **bin_attrs;
>};
># 171 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h"
>struct file;
>struct vm_area_struct;
>struct address_space;
>
>struct bin_attribute {
> struct attribute attr;
> size_t size;
> void *private;
> struct address_space *(*f_mapping)(void);
> ssize_t (*read)(struct file *, struct kobject *, struct bin_attribute *,
>   char *, loff_t, size_t);
> ssize_t (*write)(struct file *, struct kobject *, struct bin_attribute *,
>    char *, loff_t, size_t);
> int (*mmap)(struct file *, struct kobject *, struct bin_attribute *attr,
>      struct vm_area_struct *vma);
>};
># 238 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h"
>struct sysfs_ops {
> ssize_t (*show)(struct kobject *, struct attribute *, char *);
> ssize_t (*store)(struct kobject *, struct attribute *, const char *, size_t);
>};
>
>
>
>int __attribute__((__warn_unused_result__)) sysfs_create_dir_ns(struct kobject *kobj, const void *ns);
>void sysfs_remove_dir(struct kobject *kobj);
>int __attribute__((__warn_unused_result__)) sysfs_rename_dir_ns(struct kobject *kobj, const char *new_name,
>         const void *new_ns);
>int __attribute__((__warn_unused_result__)) sysfs_move_dir_ns(struct kobject *kobj,
>       struct kobject *new_parent_kobj,
>       const void *new_ns);
>int __attribute__((__warn_unused_result__)) sysfs_create_mount_point(struct kobject *parent_kobj,
>       const char *name);
>void sysfs_remove_mount_point(struct kobject *parent_kobj,
>         const char *name);
>
>int __attribute__((__warn_unused_result__)) sysfs_create_file_ns(struct kobject *kobj,
>          const struct attribute *attr,
>          const void *ns);
>int __attribute__((__warn_unused_result__)) sysfs_create_files(struct kobject *kobj,
>       const struct attribute * const *attr);
>int __attribute__((__warn_unused_result__)) sysfs_chmod_file(struct kobject *kobj,
>      const struct attribute *attr, umode_t mode);
>struct kernfs_node *sysfs_break_active_protection(struct kobject *kobj,
>        const struct attribute *attr);
>void sysfs_unbreak_active_protection(struct kernfs_node *kn);
>void sysfs_remove_file_ns(struct kobject *kobj, const struct attribute *attr,
>     const void *ns);
>bool sysfs_remove_file_self(struct kobject *kobj, const struct attribute *attr);
>void sysfs_remove_files(struct kobject *kobj, const struct attribute * const *attr);
>
>int __attribute__((__warn_unused_result__)) sysfs_create_bin_file(struct kobject *kobj,
>           const struct bin_attribute *attr);
>void sysfs_remove_bin_file(struct kobject *kobj,
>      const struct bin_attribute *attr);
>
>int __attribute__((__warn_unused_result__)) sysfs_create_link(struct kobject *kobj, struct kobject *target,
>       const char *name);
>int __attribute__((__warn_unused_result__)) sysfs_create_link_nowarn(struct kobject *kobj,
>       struct kobject *target,
>       const char *name);
>void sysfs_remove_link(struct kobject *kobj, const char *name);
>
>int sysfs_rename_link_ns(struct kobject *kobj, struct kobject *target,
>    const char *old_name, const char *new_name,
>    const void *new_ns);
>
>void sysfs_delete_link(struct kobject *dir, struct kobject *targ,
>   const char *name);
>
>int __attribute__((__warn_unused_result__)) sysfs_create_group(struct kobject *kobj,
>        const struct attribute_group *grp);
>int __attribute__((__warn_unused_result__)) sysfs_create_groups(struct kobject *kobj,
>         const struct attribute_group **groups);
>int __attribute__((__warn_unused_result__)) sysfs_update_groups(struct kobject *kobj,
>         const struct attribute_group **groups);
>int sysfs_update_group(struct kobject *kobj,
>         const struct attribute_group *grp);
>void sysfs_remove_group(struct kobject *kobj,
>   const struct attribute_group *grp);
>void sysfs_remove_groups(struct kobject *kobj,
>    const struct attribute_group **groups);
>int sysfs_add_file_to_group(struct kobject *kobj,
>   const struct attribute *attr, const char *group);
>void sysfs_remove_file_from_group(struct kobject *kobj,
>   const struct attribute *attr, const char *group);
>int sysfs_merge_group(struct kobject *kobj,
>         const struct attribute_group *grp);
>void sysfs_unmerge_group(struct kobject *kobj,
>         const struct attribute_group *grp);
>int sysfs_add_link_to_group(struct kobject *kobj, const char *group_name,
>       struct kobject *target, const char *link_name);
>void sysfs_remove_link_from_group(struct kobject *kobj, const char *group_name,
>      const char *link_name);
>int compat_only_sysfs_link_entry_to_kobj(struct kobject *kobj,
>      struct kobject *target_kobj,
>      const char *target_name,
>      const char *symlink_name);
>
>void sysfs_notify(struct kobject *kobj, const char *dir, const char *attr);
>
>int __attribute__((__warn_unused_result__)) sysfs_init(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sysfs_enable_ns(struct kernfs_node *kn)
>{
> return kernfs_enable_ns(kn);
>}
>
>int sysfs_file_change_owner(struct kobject *kobj, const char *name, kuid_t kuid,
>       kgid_t kgid);
>int sysfs_change_owner(struct kobject *kobj, kuid_t kuid, kgid_t kgid);
>int sysfs_link_change_owner(struct kobject *kobj, struct kobject *targ,
>       const char *name, kuid_t kuid, kgid_t kgid);
>int sysfs_groups_change_owner(struct kobject *kobj,
>         const struct attribute_group **groups,
>         kuid_t kuid, kgid_t kgid);
>int sysfs_group_change_owner(struct kobject *kobj,
>        const struct attribute_group *groups, kuid_t kuid,
>        kgid_t kgid);
>__attribute__((__format__(printf, 2, 3)))
>int sysfs_emit(char *buf, const char *fmt, ...);
>__attribute__((__format__(printf, 3, 4)))
>int sysfs_emit_at(char *buf, int at, const char *fmt, ...);
># 604 "/usr/src/linux-5.14.21-150500.53/include/linux/sysfs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) sysfs_create_file(struct kobject *kobj,
>       const struct attribute *attr)
>{
> return sysfs_create_file_ns(kobj, attr, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sysfs_remove_file(struct kobject *kobj,
>         const struct attribute *attr)
>{
> sysfs_remove_file_ns(kobj, attr, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sysfs_rename_link(struct kobject *kobj, struct kobject *target,
>        const char *old_name, const char *new_name)
>{
> return sysfs_rename_link_ns(kobj, target, old_name, new_name, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sysfs_notify_dirent(struct kernfs_node *kn)
>{
> kernfs_notify(kn);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *sysfs_get_dirent(struct kernfs_node *parent,
>         const char *name)
>{
> return kernfs_find_and_get(parent, name);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kernfs_node *sysfs_get(struct kernfs_node *kn)
>{
> kernfs_get(kn);
> return kn;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sysfs_put(struct kernfs_node *kn)
>{
> kernfs_put(kn);
>}
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kref.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/kref.h"
>struct kref {
> refcount_t refcount;
>};
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kref_init(struct kref *kref)
>{
> refcount_set(&kref->refcount, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int kref_read(const struct kref *kref)
>{
> return refcount_read(&kref->refcount);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kref_get(struct kref *kref)
>{
> refcount_inc(&kref->refcount);
>}
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/kref.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kref_put(struct kref *kref, void (*release)(struct kref *kref))
>{
> if (refcount_dec_and_test(&kref->refcount)) {
>  release(kref);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kref_put_mutex(struct kref *kref,
>     void (*release)(struct kref *kref),
>     struct mutex *lock)
>{
> if (refcount_dec_and_mutex_lock(&kref->refcount, lock)) {
>  release(kref);
>  return 1;
> }
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kref_put_lock(struct kref *kref,
>    void (*release)(struct kref *kref),
>    spinlock_t *lock)
>{
> if (refcount_dec_and_lock(&kref->refcount, lock)) {
>  release(kref);
>  return 1;
> }
> return 0;
>}
># 109 "/usr/src/linux-5.14.21-150500.53/include/linux/kref.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) kref_get_unless_zero(struct kref *kref)
>{
> return refcount_inc_not_zero(&kref->refcount);
>}
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h" 2
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h"
>extern char uevent_helper[];
>
>
>
>extern u64 uevent_seqnum;
># 53 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h"
>enum kobject_action {
> KOBJ_ADD,
> KOBJ_REMOVE,
> KOBJ_CHANGE,
> KOBJ_MOVE,
> KOBJ_ONLINE,
> KOBJ_OFFLINE,
> KOBJ_BIND,
> KOBJ_UNBIND,
>};
>
>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;
>};
>
>extern __attribute__((__format__(printf, 2, 3)))
>int kobject_set_name(struct kobject *kobj, const char *name, ...);
>extern __attribute__((__format__(printf, 2, 0)))
>int kobject_set_name_vargs(struct kobject *kobj, const char *fmt,
>      va_list vargs);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *kobject_name(const struct kobject *kobj)
>{
> return kobj->name;
>}
>
>extern void kobject_init(struct kobject *kobj, struct kobj_type *ktype);
>extern __attribute__((__format__(printf, 3, 4))) __attribute__((__warn_unused_result__))
>int kobject_add(struct kobject *kobj, struct kobject *parent,
>  const char *fmt, ...);
>extern __attribute__((__format__(printf, 4, 5))) __attribute__((__warn_unused_result__))
>int kobject_init_and_add(struct kobject *kobj,
>    struct kobj_type *ktype, struct kobject *parent,
>    const char *fmt, ...);
>
>extern void kobject_del(struct kobject *kobj);
>
>extern struct kobject * __attribute__((__warn_unused_result__)) kobject_create(void);
>extern struct kobject * __attribute__((__warn_unused_result__)) kobject_create_and_add(const char *name,
>      struct kobject *parent);
>
>extern int __attribute__((__warn_unused_result__)) kobject_rename(struct kobject *, const char *new_name);
>extern int __attribute__((__warn_unused_result__)) kobject_move(struct kobject *, struct kobject *);
>
>extern struct kobject *kobject_get(struct kobject *kobj);
>extern struct kobject * __attribute__((__warn_unused_result__)) kobject_get_unless_zero(
>      struct kobject *kobj);
>extern void kobject_put(struct kobject *kobj);
>
>extern const void *kobject_namespace(struct kobject *kobj);
>extern void kobject_get_ownership(struct kobject *kobj,
>      kuid_t *uid, kgid_t *gid);
>extern char *kobject_get_path(struct kobject *kobj, gfp_t flag);
># 131 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kobject_has_children(struct kobject *kobj)
>{
> ({ int __ret_warn_on = !!(kref_read(&kobj->kref) == 0); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h"), "i" (133), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("257" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "257" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>
> return kobj->sd && kobj->sd->dir.subdirs;
>}
>
>struct kobj_type {
> void (*release)(struct kobject *kobj);
> const struct sysfs_ops *sysfs_ops;
> struct attribute **default_attrs;
> const struct attribute_group **default_groups;
> const struct kobj_ns_type_operations *(*child_ns_type)(struct kobject *kobj);
> const void *(*namespace)(struct kobject *kobj);
> void (*get_ownership)(struct kobject *kobj, kuid_t *uid, kgid_t *gid);
>};
>
>struct kobj_uevent_env {
> char *argv[3];
> char *envp[64];
> int envp_idx;
> char buf[2048];
> int buflen;
>};
>
>struct kset_uevent_ops {
> int (* const filter)(struct kobject *kobj);
> const char *(* const name)(struct kobject *kobj);
> int (* const uevent)(struct kobject *kobj, struct kobj_uevent_env *env);
>};
>
>struct kobj_attribute {
> struct attribute attr;
> ssize_t (*show)(struct kobject *kobj, struct kobj_attribute *attr,
>   char *buf);
> ssize_t (*store)(struct kobject *kobj, struct kobj_attribute *attr,
>    const char *buf, size_t count);
>};
>
>extern const struct sysfs_ops kobj_sysfs_ops;
>
>struct sock;
># 191 "/usr/src/linux-5.14.21-150500.53/include/linux/kobject.h"
>struct kset {
> struct list_head list;
> spinlock_t list_lock;
> struct kobject kobj;
> const struct kset_uevent_ops *uevent_ops;
>} __attribute__((__designated_init__));
>
>extern void kset_init(struct kset *kset);
>extern int __attribute__((__warn_unused_result__)) kset_register(struct kset *kset);
>extern void kset_unregister(struct kset *kset);
>extern struct kset * __attribute__((__warn_unused_result__)) kset_create_and_add(const char *name,
>      const struct kset_uevent_ops *u,
>      struct kobject *parent_kobj);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kset *to_kset(struct kobject *kobj)
>{
> return kobj ? ({ void *__mptr = (void *)(kobj); do { extern void __compiletime_assert_258(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(kobj)), typeof(((struct kset *)0)->kobj)) && !__builtin_types_compatible_p(typeof(*(kobj)), typeof(void))))) __compiletime_assert_258(); } while (0); ((struct kset *)(__mptr - __builtin_offsetof(struct kset, kobj))); }) : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kset *kset_get(struct kset *k)
>{
> return k ? to_kset(kobject_get(&k->kobj)) : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kset_put(struct kset *k)
>{
> kobject_put(&k->kobj);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kobj_type *get_ktype(struct kobject *kobj)
>{
> return kobj->ktype;
>}
>
>extern struct kobject *kset_find_obj(struct kset *, const char *);
>
>
>extern struct kobject *kernel_kobj;
>
>extern struct kobject *mm_kobj;
>
>extern struct kobject *hypervisor_kobj;
>
>extern struct kobject *power_kobj;
>
>extern struct kobject *firmware_kobj;
>
>int kobject_uevent(struct kobject *kobj, enum kobject_action action);
>int kobject_uevent_env(struct kobject *kobj, enum kobject_action action,
>   char *envp[]);
>int kobject_synth_uevent(struct kobject *kobj, const char *buf, size_t count);
>
>__attribute__((__format__(printf, 2, 3)))
>int add_uevent_var(struct kobj_uevent_env *env, const char *format, ...);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h" 1
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>struct kernel_param;
>
>
>
>
>
>
>enum {
> KERNEL_PARAM_OPS_FL_NOARG = (1 << 0)
>};
>
>struct kernel_param_ops {
>
> unsigned int flags;
>
> int (*set)(const char *val, const struct kernel_param *kp);
>
> int (*get)(char *buffer, const struct kernel_param *kp);
>
> void (*free)(void *arg);
>};
>
>
>
>
>
>
>
>enum {
> KERNEL_PARAM_FL_UNSAFE = (1 << 0),
> KERNEL_PARAM_FL_HWPARAM = (1 << 1),
>};
>
>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;
> };
>};
>
>extern const struct kernel_param __start___param[], __stop___param[];
>
>
>struct kparam_string {
> unsigned int maxlen;
> char *string;
>};
>
>
>struct kparam_array
>{
> unsigned int max;
> unsigned int elemsize;
> unsigned int *num;
> const struct kernel_param_ops *ops;
> void *elem;
>};
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>extern void kernel_param_lock(struct module *mod);
>extern void kernel_param_unlock(struct module *mod);
># 372 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>extern bool parameq(const char *name1, const char *name2);
># 382 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>extern bool parameqn(const char *name1, const char *name2, size_t n);
>
>
>extern char *parse_args(const char *name,
>        char *args,
>        const struct kernel_param *params,
>        unsigned num,
>        s16 level_min,
>        s16 level_max,
>        void *arg,
>        int (*unknown)(char *param, char *val,
>         const char *doing, void *arg));
>
>
>
>extern void destroy_params(const struct kernel_param *params, unsigned num);
># 411 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>extern const struct kernel_param_ops param_ops_byte;
>extern int param_set_byte(const char *val, const struct kernel_param *kp);
>extern int param_get_byte(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_short;
>extern int param_set_short(const char *val, const struct kernel_param *kp);
>extern int param_get_short(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_ushort;
>extern int param_set_ushort(const char *val, const struct kernel_param *kp);
>extern int param_get_ushort(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_int;
>extern int param_set_int(const char *val, const struct kernel_param *kp);
>extern int param_get_int(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_uint;
>extern int param_set_uint(const char *val, const struct kernel_param *kp);
>extern int param_get_uint(char *buffer, const struct kernel_param *kp);
>int param_set_uint_minmax(const char *val, const struct kernel_param *kp,
>  unsigned int min, unsigned int max);
>
>
>extern const struct kernel_param_ops param_ops_long;
>extern int param_set_long(const char *val, const struct kernel_param *kp);
>extern int param_get_long(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_ulong;
>extern int param_set_ulong(const char *val, const struct kernel_param *kp);
>extern int param_get_ulong(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_ullong;
>extern int param_set_ullong(const char *val, const struct kernel_param *kp);
>extern int param_get_ullong(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_hexint;
>extern int param_set_hexint(const char *val, const struct kernel_param *kp);
>extern int param_get_hexint(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_charp;
>extern int param_set_charp(const char *val, const struct kernel_param *kp);
>extern int param_get_charp(char *buffer, const struct kernel_param *kp);
>extern void param_free_charp(void *arg);
>
>
>
>extern const struct kernel_param_ops param_ops_bool;
>extern int param_set_bool(const char *val, const struct kernel_param *kp);
>extern int param_get_bool(char *buffer, const struct kernel_param *kp);
>
>
>extern const struct kernel_param_ops param_ops_bool_enable_only;
>extern int param_set_bool_enable_only(const char *val,
>          const struct kernel_param *kp);
>
>
>
>extern const struct kernel_param_ops param_ops_invbool;
>extern int param_set_invbool(const char *val, const struct kernel_param *kp);
>extern int param_get_invbool(char *buffer, const struct kernel_param *kp);
>
>
>
>extern const struct kernel_param_ops param_ops_bint;
>extern int param_set_bint(const char *val, const struct kernel_param *kp);
># 526 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>enum hwparam_type {
> hwparam_ioport,
> hwparam_iomem,
> hwparam_ioport_or_iomem,
> hwparam_irq,
> hwparam_dma,
> hwparam_dma_addr,
> hwparam_other,
>};
># 587 "/usr/src/linux-5.14.21-150500.53/include/linux/moduleparam.h"
>extern const struct kernel_param_ops param_array_ops;
>
>extern const struct kernel_param_ops param_ops_string;
>extern int param_set_copystring(const char *val, const struct kernel_param *);
>extern int param_get_string(char *buffer, const struct kernel_param *kp);
>
>
>
>struct module;
>
>
>extern int module_param_sysfs_setup(struct module *mod,
>        const struct kernel_param *kparam,
>        unsigned int num_params);
>
>extern void module_param_sysfs_remove(struct module *mod);
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_latch.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_latch.h"
>struct latch_tree_node {
> struct rb_node node[2];
>};
>
>struct latch_tree_root {
> seqcount_latch_t seq;
> struct rb_root tree[2];
>};
># 64 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_latch.h"
>struct latch_tree_ops {
> bool (*less)(struct latch_tree_node *a, struct latch_tree_node *b);
> int (*comp)(void *key, struct latch_tree_node *b);
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct latch_tree_node *
>__lt_from_rb(struct rb_node *node, int idx)
>{
> return ({ void *__mptr = (void *)(node); do { extern void __compiletime_assert_259(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(node)), typeof(((struct latch_tree_node *)0)->node[idx])) && !__builtin_types_compatible_p(typeof(*(node)), typeof(void))))) __compiletime_assert_259(); } while (0); ((struct latch_tree_node *)(__mptr - __builtin_offsetof(struct latch_tree_node, node[idx]))); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>__lt_insert(struct latch_tree_node *ltn, struct latch_tree_root *ltr, int idx,
>     bool (*less)(struct latch_tree_node *a, struct latch_tree_node *b))
>{
> struct rb_root *root = &ltr->tree[idx];
> struct rb_node **link = &root->rb_node;
> struct rb_node *node = &ltn->node[idx];
> struct rb_node *parent = ((void *)0);
> struct latch_tree_node *ltp;
>
> while (*link) {
>  parent = *link;
>  ltp = __lt_from_rb(parent, idx);
>
>  if (less(ltn, ltp))
>   link = &parent->rb_left;
>  else
>   link = &parent->rb_right;
> }
>
> rb_link_node_rcu(node, parent, link);
> rb_insert_color(node, root);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>__lt_erase(struct latch_tree_node *ltn, struct latch_tree_root *ltr, int idx)
>{
> rb_erase(&ltn->node[idx], &ltr->tree[idx]);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct latch_tree_node *
>__lt_find(void *key, struct latch_tree_root *ltr, int idx,
>   int (*comp)(void *key, struct latch_tree_node *node))
>{
> struct rb_node *node = ({ typeof(ltr->tree[idx].rb_node) ________p1 = ({ do { extern void __compiletime_assert_260(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(ltr->tree[idx].rb_node) == sizeof(char) || sizeof(ltr->tree[idx].rb_node) == sizeof(short) || sizeof(ltr->tree[idx].rb_node) == sizeof(int) || sizeof(ltr->tree[idx].rb_node) == sizeof(long)) || sizeof(ltr->tree[idx].rb_node) == sizeof(long long))) __compiletime_assert_260(); } while (0); (*(const volatile typeof( _Generic((ltr->tree[idx].rb_node), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (ltr->tree[idx].rb_node))) *)&(ltr->tree[idx].rb_node)); }); ((typeof(*ltr->tree[idx].rb_node) *)(________p1)); });
> struct latch_tree_node *ltn;
> int c;
>
> while (node) {
>  ltn = __lt_from_rb(node, idx);
>  c = comp(key, ltn);
>
>  if (c < 0)
>   node = ({ typeof(node->rb_left) ________p1 = ({ do { extern void __compiletime_assert_261(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(node->rb_left) == sizeof(char) || sizeof(node->rb_left) == sizeof(short) || sizeof(node->rb_left) == sizeof(int) || sizeof(node->rb_left) == sizeof(long)) || sizeof(node->rb_left) == sizeof(long long))) __compiletime_assert_261(); } while (0); (*(const volatile typeof( _Generic((node->rb_left), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (node->rb_left))) *)&(node->rb_left)); }); ((typeof(*node->rb_left) *)(________p1)); });
>  else if (c > 0)
>   node = ({ typeof(node->rb_right) ________p1 = ({ do { extern void __compiletime_assert_262(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(node->rb_right) == sizeof(char) || sizeof(node->rb_right) == sizeof(short) || sizeof(node->rb_right) == sizeof(int) || sizeof(node->rb_right) == sizeof(long)) || sizeof(node->rb_right) == sizeof(long long))) __compiletime_assert_262(); } while (0); (*(const volatile typeof( _Generic((node->rb_right), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (node->rb_right))) *)&(node->rb_right)); }); ((typeof(*node->rb_right) *)(________p1)); });
>  else
>   return ltn;
> }
>
> return ((void *)0);
>}
># 143 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_latch.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>latch_tree_insert(struct latch_tree_node *node,
>    struct latch_tree_root *root,
>    const struct latch_tree_ops *ops)
>{
> raw_write_seqcount_latch(&root->seq);
> __lt_insert(node, root, 0, ops->less);
> raw_write_seqcount_latch(&root->seq);
> __lt_insert(node, root, 1, ops->less);
>}
># 170 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_latch.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void
>latch_tree_erase(struct latch_tree_node *node,
>   struct latch_tree_root *root,
>   const struct latch_tree_ops *ops)
>{
> raw_write_seqcount_latch(&root->seq);
> __lt_erase(node, root, 0);
> raw_write_seqcount_latch(&root->seq);
> __lt_erase(node, root, 1);
>}
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/rbtree_latch.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct latch_tree_node *
>latch_tree_find(void *key, struct latch_tree_root *root,
>  const struct latch_tree_ops *ops)
>{
> struct latch_tree_node *node;
> unsigned int seq;
>
> do {
>  seq = raw_read_seqcount_latch(&root->seq);
>  node = __lt_find(key, root, seq & 1, ops->comp);
> } while (read_seqcount_latch_retry(&root->seq, seq));
>
> return node;
>}
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/error-injection.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/error-injection.h" 1
>
>
>
>
>
>enum {
> EI_ETYPE_NONE,
> EI_ETYPE_NULL,
> EI_ETYPE_ERRNO,
> EI_ETYPE_ERRNO_NULL,
> EI_ETYPE_TRUE,
>};
>
>struct error_injection_entry {
> unsigned long addr;
> int etype;
>};
>
>struct pt_regs;
># 34 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/error-injection.h"
>void override_function_with_return(struct pt_regs *regs);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/error-injection.h" 2
>
>
>
>extern bool within_error_injection_list(unsigned long addr);
>extern int get_injectable_error_type(unsigned long addr);
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cfi.h" 1
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/module.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/module.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/module.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/orc_types.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/module.h" 2
>
>struct mod_arch_specific {
>
> unsigned int num_orcs;
> int *orc_unwind_ip;
> struct orc_entry *orc_unwind;
>
>};
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h" 2
>
>
>
>struct modversion_info {
> unsigned long crc;
> char name[(64 - sizeof(unsigned long))];
>};
>
>struct module;
>struct exception_table_entry;
>
>struct module_kobject {
> struct kobject kobj;
> struct module *mod;
> struct kobject *drivers_dir;
> struct module_param_attrs *mp;
> struct completion *kobj_completion;
>} __attribute__((__designated_init__));
>
>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 count);
> void (*setup)(struct module *, const char *);
> int (*test)(struct module *);
> void (*free)(struct module *);
>};
>
>struct module_version_attribute {
> struct module_attribute mattr;
> const char *module_name;
> const char *version;
>};
>
>extern ssize_t __modver_version_show(struct module_attribute *,
>         struct module_kobject *, char *);
>
>extern struct module_attribute module_uevent;
>
>
>extern int init_module(void);
>extern void cleanup_module(void);
># 295 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>struct notifier_block;
>
>
>
>extern int modules_disabled;
>
>void *__symbol_get(const char *symbol);
>void *__symbol_get_gpl(const char *symbol);
>
>
>
>struct module_use {
> struct list_head source_list;
> struct list_head target_list;
> struct module *source, *target;
>};
>
>enum module_state {
> MODULE_STATE_LIVE,
> MODULE_STATE_COMING,
> MODULE_STATE_GOING,
> MODULE_STATE_UNFORMED,
>};
>
>struct mod_tree_node {
> struct module *mod;
> struct latch_tree_node node;
>};
>
>struct module_layout {
>
> void *base;
>
> unsigned int size;
>
> unsigned int text_size;
>
> unsigned int ro_size;
>
> unsigned int ro_after_init_size;
>
>
> struct mod_tree_node mtn;
>
>};
># 348 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>struct mod_kallsyms {
> Elf64_Sym *symtab;
> unsigned int num_symtab;
> char *strtab;
> char *typetab;
>};
>
>
>struct klp_modinfo {
> Elf64_Ehdr hdr;
> Elf64_Shdr *sechdrs;
> char *secstrings;
> unsigned int symndx;
>};
>
>
>struct module {
> enum module_state state;
>
>
> struct list_head list;
>
>
> char name[(64 - sizeof(unsigned long))];
>
>
>
> unsigned char build_id[20];
>
>
>
> 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 s32 *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 s32 *gpl_crcs;
> bool using_gplonly_symbols;
>
>
>
> bool sig_ok;
>
>
> bool async_probe_requested;
>
>
> unsigned int num_exentries;
> struct exception_table_entry *extable;
>
>
> int (*init)(void);
>
>
> struct module_layout core_layout __attribute__((__aligned__((1 << (6)))));
> struct module_layout init_layout;
>
>
> struct mod_arch_specific arch;
>
> unsigned long taints;
>
>
>
> unsigned num_bugs;
> struct list_head bug_list;
> struct bug_entry *bug_table;
>
>
>
>
> struct mod_kallsyms *kallsyms;
> struct mod_kallsyms core_kallsyms;
>
>
> struct module_sect_attrs *sect_attrs;
>
>
> struct module_notes_attrs *notes_attrs;
>
>
>
>
> char *args;
>
>
>
> void *percpu;
> unsigned int percpu_size;
>
> void *noinstr_text_start;
> unsigned int noinstr_text_size;
>
>
> unsigned int num_tracepoints;
> tracepoint_ptr_t *tracepoints_ptrs;
>
>
> unsigned int num_srcu_structs;
> struct srcu_struct **srcu_struct_ptrs;
>
>
> unsigned int num_bpf_raw_events;
> struct bpf_raw_event_map *bpf_raw_events;
>
>
> unsigned int btf_data_size;
> void *btf_data;
>
>
> struct jump_entry *jump_entries;
> unsigned int num_jump_entries;
>
>
> unsigned int num_trace_bprintk_fmt;
> const char **trace_bprintk_fmt_start;
>
>
> struct trace_event_call **trace_events;
> unsigned int num_trace_events;
> struct trace_eval_map **trace_evals;
> unsigned int num_trace_evals;
>
>
> unsigned int num_ftrace_callsites;
> unsigned long *ftrace_callsites;
>
>
> void *kprobes_text_start;
> unsigned int kprobes_text_size;
> unsigned long *kprobe_blacklist;
> unsigned int num_kprobe_blacklist;
>
>
> int num_static_call_sites;
> struct static_call_site *static_call_sites;
>
>
>
> bool klp;
> bool klp_alive;
>
>
> struct klp_modinfo *klp_info;
>
>
>
>
> struct list_head source_list;
>
> struct list_head target_list;
>
>
> void (*exit)(void);
>
> atomic_t refcnt;
># 533 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
> struct error_injection_entry *ei_funcs;
> unsigned int num_ei_funcs;
>
> void *suse_kabi_padding;
>} __attribute__((__aligned__((1 << (6))))) __attribute__((__designated_init__));
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long kallsyms_symbol_value(const Elf64_Sym *sym)
>{
> return sym->st_value;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool module_is_live(struct module *mod)
>{
> return mod->state != MODULE_STATE_GOING;
>}
>
>struct module *__module_text_address(unsigned long addr);
>struct module *__module_address(unsigned long addr);
>bool is_module_address(unsigned long addr);
>bool __is_module_percpu_address(unsigned long addr, unsigned long *can_addr);
>bool is_module_percpu_address(unsigned long addr);
>bool is_module_text_address(unsigned long addr);
>
>const char *supported_printable(int taint);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool within_module_core(unsigned long addr,
>          const struct module *mod)
>{
> return (unsigned long)mod->core_layout.base <= addr &&
>        addr < (unsigned long)mod->core_layout.base + mod->core_layout.size;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool within_module_init(unsigned long addr,
>          const struct module *mod)
>{
> return (unsigned long)mod->init_layout.base <= addr &&
>        addr < (unsigned long)mod->init_layout.base + mod->init_layout.size;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool within_module(unsigned long addr, const struct module *mod)
>{
> return within_module_init(addr, mod) || within_module_core(addr, mod);
>}
>
>
>struct module *find_module(const char *name);
>
>
>
>int module_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
>   char *name, char *module_name, int *exported);
>
>
>unsigned long module_kallsyms_lookup_name(const char *name);
>
>extern void __attribute__((__noreturn__)) __module_put_and_exit(struct module *mod,
>   long code);
>
>
>
>int module_refcount(struct module *mod);
>void __symbol_put(const char *symbol);
>
>void symbol_put_addr(void *addr);
>
>
>
>extern void __module_get(struct module *module);
>
>
>
>extern bool try_module_get(struct module *module);
>
>extern void module_put(struct module *module);
># 641 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>void *dereference_module_function_descriptor(struct module *mod, void *ptr);
>
>
>
>
>const char *module_address_lookup(unsigned long addr,
>       unsigned long *symbolsize,
>       unsigned long *offset,
>       char **modname, const unsigned char **modbuildid,
>       char *namebuf);
>int lookup_module_symbol_name(unsigned long addr, char *symname);
>int lookup_module_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
>
>int register_module_notifier(struct notifier_block *nb);
>int unregister_module_notifier(struct notifier_block *nb);
>
>extern void print_modules(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool module_requested_async_probing(struct module *module)
>{
> return module && module->async_probe_requested;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_livepatch_module(struct module *mod)
>{
> return mod->klp;
>}
>
>
>
>
>
>
>
>bool is_module_sig_enforced(void);
>void set_module_sig_enforced(void);
># 822 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>extern struct kset *module_kset;
>extern struct kobj_type module_ktype;
>extern int module_sysfs_initialized;
># 834 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>void module_bug_finalize(const Elf64_Ehdr *, const Elf64_Shdr *,
>    struct module *);
>void module_bug_cleanup(struct module *);
># 849 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>extern bool retpoline_module_ok(bool has_retpoline);
># 858 "/usr/src/linux-5.14.21-150500.53/include/linux/module.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool module_sig_ok(struct module *module)
>{
> return module->sig_ok;
>}
>
>
>
>
>
>
>
>int module_kallsyms_on_each_symbol(int (*fn)(void *, const char *,
>          struct module *, unsigned long),
>       void *data);
># 66 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 89 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ctype.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/ctype.h"
>extern const unsigned char _ctype[];
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/ctype.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int isdigit(int c)
>{
> return '0' <= c && c <= '9';
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char __tolower(unsigned char c)
>{
> if ((((_ctype[(int)(unsigned char)(c)])&(0x01)) != 0))
>  c -= 'A'-'a';
> return c;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char __toupper(unsigned char c)
>{
> if ((((_ctype[(int)(unsigned char)(c)])&(0x02)) != 0))
>  c -= 'a'-'A';
> return c;
>}
># 70 "/usr/src/linux-5.14.21-150500.53/include/linux/ctype.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) char _tolower(const char c)
>{
> return c | 0x20;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int isodigit(const char c)
>{
> return c >= '0' && c <= '7';
>}
># 90 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/console.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/console.h"
>struct vc_data;
>struct console_font_op;
>struct console_font;
>struct module;
>struct tty_struct;
>struct notifier_block;
>
>enum con_scroll {
> SM_UP,
> SM_DOWN,
>};
>
>enum vc_intensity;
># 44 "/usr/src/linux-5.14.21-150500.53/include/linux/console.h"
>struct consw {
> struct module *owner;
> const char *(*con_startup)(void);
> void (*con_init)(struct vc_data *vc, int init);
> void (*con_deinit)(struct vc_data *vc);
> void (*con_clear)(struct vc_data *vc, int sy, int sx, int height,
>   int width);
> void (*con_putc)(struct vc_data *vc, int c, int ypos, int xpos);
> void (*con_putcs)(struct vc_data *vc, const unsigned short *s,
>   int count, int ypos, int xpos);
> void (*con_cursor)(struct vc_data *vc, int mode);
> bool (*con_scroll)(struct vc_data *vc, unsigned int top,
>   unsigned int bottom, enum con_scroll dir,
>   unsigned int lines);
> int (*con_switch)(struct vc_data *vc);
> int (*con_blank)(struct vc_data *vc, int blank, int mode_switch);
> int (*con_font_set)(struct vc_data *vc, struct console_font *font,
>   unsigned int flags);
> int (*con_font_get)(struct vc_data *vc, struct console_font *font);
> int (*con_font_default)(struct vc_data *vc,
>   struct console_font *font, char *name);
> int (*con_resize)(struct vc_data *vc, unsigned int width,
>   unsigned int height, unsigned int user);
> void (*con_set_palette)(struct vc_data *vc,
>   const unsigned char *table);
> void (*con_scrolldelta)(struct vc_data *vc, int lines);
> int (*con_set_origin)(struct vc_data *vc);
> void (*con_save_screen)(struct vc_data *vc);
> u8 (*con_build_attr)(struct vc_data *vc, u8 color,
>   enum vc_intensity intensity,
>   bool blink, bool underline, bool reverse, bool italic);
> void (*con_invert_region)(struct vc_data *vc, u16 *p, int count);
> u16 *(*con_screen_pos)(const struct vc_data *vc, int offset);
> unsigned long (*con_getxy)(struct vc_data *vc, unsigned long position,
>   int *px, int *py);
>
>
>
> void (*con_flush_scrollback)(struct vc_data *vc);
>
>
>
>
>
> int (*con_debug_enter)(struct vc_data *vc);
>
>
>
> int (*con_debug_leave)(struct vc_data *vc);
>};
>
>extern const struct consw *conswitchp;
>
>extern const struct consw dummy_con;
>extern const struct consw vga_con;
>extern const struct consw newport_con;
>
>int con_is_bound(const struct consw *csw);
>int do_unregister_con_driver(const struct consw *csw);
>int do_take_over_console(const struct consw *sw, int first, int last, int deflt);
>void give_up_console(const struct consw *sw);
>
>int con_debug_enter(struct vc_data *vc);
>int con_debug_leave(void);
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/console.h"
>struct console {
> char name[16];
> void (*write)(struct console *, const char *, unsigned);
> int (*read)(struct console *, char *, unsigned);
> struct tty_driver *(*device)(struct console *, int *);
> void (*unblank)(void);
> int (*setup)(struct console *, char *);
> int (*exit)(struct console *);
> int (*match)(struct console *, char *name, int idx, char *options);
> short flags;
> short index;
> int cflag;
> uint ispeed;
> uint ospeed;
> void *data;
> struct console *next;
>};
>
>
>
>
>
>
>
>extern int console_set_on_cmdline;
>extern struct console *early_console;
>
>enum con_flush_mode {
> CONSOLE_FLUSH_PENDING,
> CONSOLE_REPLAY_ALL,
>};
>
>extern int add_preferred_console(char *name, int idx, char *options);
>extern void register_console(struct console *);
>extern int unregister_console(struct console *);
>extern struct console *console_drivers;
>extern void console_lock(void);
>extern int console_trylock(void);
>extern void console_unlock(void);
>extern void console_conditional_schedule(void);
>extern void console_unblank(void);
>extern void console_flush_on_panic(enum con_flush_mode mode);
>extern struct tty_driver *console_device(int *);
>extern void console_stop(struct console *);
>extern void console_start(struct console *);
>extern int is_console_locked(void);
>extern int braille_register_console(struct console *, int index,
>  char *console_options, char *braille_options);
>extern int braille_unregister_console(struct console *);
>
>extern void console_sysfs_notify(void);
>
>
>
>
>extern bool console_suspend_enabled;
>
>
>extern void suspend_console(void);
>extern void resume_console(void);
>
>int mda_console_init(void);
>
>void vcs_make_sysfs(int index);
>void vcs_remove_sysfs(int index);
># 214 "/usr/src/linux-5.14.21-150500.53/include/linux/console.h"
>extern atomic_t ignore_console_lock_warning;
># 223 "/usr/src/linux-5.14.21-150500.53/include/linux/console.h"
>extern bool vgacon_text_force(void);
>
>
>
>
>extern void console_init(void);
>
>
>void dummycon_register_output_notifier(struct notifier_block *nb);
>void dummycon_unregister_output_notifier(struct notifier_block *nb);
># 91 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct device;
>struct clk;
>struct device_node;
>struct of_phandle_args;
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk_notifier {
> struct clk *clk;
> struct srcu_notifier_head notifier_head;
> struct list_head node;
>};
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk_notifier_data {
> struct clk *clk;
> unsigned long old_rate;
> unsigned long new_rate;
>};
># 87 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk_bulk_data {
> const char *id;
> struct clk *clk;
>};
># 103 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_notifier_register(struct clk *clk, struct notifier_block *nb);
>
>
>
>
>
>
>int clk_notifier_unregister(struct clk *clk, struct notifier_block *nb);
># 120 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int devm_clk_notifier_register(struct device *dev, struct clk *clk,
>          struct notifier_block *nb);
># 131 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>long clk_get_accuracy(struct clk *clk);
># 141 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_phase(struct clk *clk, int degrees);
># 150 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_get_phase(struct clk *clk);
># 161 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_duty_cycle(struct clk *clk, unsigned int num, unsigned int den);
># 171 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_get_scaled_duty_cycle(struct clk *clk, unsigned int scale);
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>bool clk_is_match(const struct clk *p, const struct clk *q);
># 250 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_prepare(struct clk *clk);
>int __attribute__((__warn_unused_result__)) clk_bulk_prepare(int num_clks,
>      const struct clk_bulk_data *clks);
># 269 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>bool clk_is_enabled_when_prepared(struct clk *clk);
># 300 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_unprepare(struct clk *clk);
>void clk_bulk_unprepare(int num_clks, const struct clk_bulk_data *clks);
># 330 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *clk_get(struct device *dev, const char *id);
># 352 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) clk_bulk_get(struct device *dev, int num_clks,
>         struct clk_bulk_data *clks);
># 372 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) clk_bulk_get_all(struct device *dev,
>      struct clk_bulk_data **clks);
># 385 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) clk_bulk_get_optional(struct device *dev, int num_clks,
>           struct clk_bulk_data *clks);
># 399 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) devm_clk_bulk_get(struct device *dev, int num_clks,
>       struct clk_bulk_data *clks);
># 422 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) devm_clk_bulk_get_optional(struct device *dev, int num_clks,
>         struct clk_bulk_data *clks);
># 438 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) devm_clk_bulk_get_all(struct device *dev,
>           struct clk_bulk_data **clks);
># 459 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_clk_get(struct device *dev, const char *id);
># 480 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_clk_get_prepared(struct device *dev, const char *id);
># 500 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_clk_get_enabled(struct device *dev, const char *id);
># 511 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_clk_get_optional(struct device *dev, const char *id);
># 533 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_clk_get_optional_prepared(struct device *dev, const char *id);
># 555 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_clk_get_optional_enabled(struct device *dev, const char *id);
># 571 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *devm_get_clk_from_child(struct device *dev,
>        struct device_node *np, const char *con_id);
># 589 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_rate_exclusive_get(struct clk *clk);
># 604 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_rate_exclusive_put(struct clk *clk);
># 616 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_enable(struct clk *clk);
># 627 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int __attribute__((__warn_unused_result__)) clk_bulk_enable(int num_clks,
>     const struct clk_bulk_data *clks);
># 644 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_disable(struct clk *clk);
># 662 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_bulk_disable(int num_clks, const struct clk_bulk_data *clks);
>
>
>
>
>
>
>unsigned long clk_get_rate(struct clk *clk);
># 681 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_put(struct clk *clk);
># 694 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_bulk_put(int num_clks, struct clk_bulk_data *clks);
># 707 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void clk_bulk_put_all(int num_clks, struct clk_bulk_data *clks);
># 720 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>void devm_clk_put(struct device *dev, struct clk *clk);
># 748 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>long clk_round_rate(struct clk *clk, unsigned long rate);
># 760 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_rate(struct clk *clk, unsigned long rate);
># 777 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_rate_exclusive(struct clk *clk, unsigned long rate);
># 789 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>bool clk_has_parent(struct clk *clk, struct clk *parent);
># 799 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_rate_range(struct clk *clk, unsigned long min, unsigned long max);
># 808 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_min_rate(struct clk *clk, unsigned long rate);
># 817 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_max_rate(struct clk *clk, unsigned long rate);
># 826 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_set_parent(struct clk *clk, struct clk *parent);
># 835 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *clk_get_parent(struct clk *clk);
># 852 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>struct clk *clk_get_sys(const char *dev_id, const char *con_id);
># 861 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>int clk_save_context(void);
>
>
>
>
>
>
>
>void clk_restore_context(void);
># 1055 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int clk_prepare_enable(struct clk *clk)
>{
> int ret;
>
> ret = clk_prepare(clk);
> if (ret)
>  return ret;
> ret = clk_enable(clk);
> if (ret)
>  clk_unprepare(clk);
>
> return ret;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clk_disable_unprepare(struct clk *clk)
>{
> clk_disable(clk);
> clk_unprepare(clk);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__))
>clk_bulk_prepare_enable(int num_clks, const struct clk_bulk_data *clks)
>{
> int ret;
>
> ret = clk_bulk_prepare(num_clks, clks);
> if (ret)
>  return ret;
> ret = clk_bulk_enable(num_clks, clks);
> if (ret)
>  clk_bulk_unprepare(num_clks, clks);
>
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clk_bulk_disable_unprepare(int num_clks,
>           const struct clk_bulk_data *clks)
>{
> clk_bulk_disable(num_clks, clks);
> clk_bulk_unprepare(num_clks, clks);
>}
># 1107 "/usr/src/linux-5.14.21-150500.53/include/linux/clk.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct clk *clk_get_optional(struct device *dev, const char *id)
>{
> struct clk *clk = clk_get(dev, id);
>
> if (clk == ERR_PTR(-2))
>  return ((void *)0);
>
> return clk;
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct clk *of_clk_get(struct device_node *np, int index)
>{
> return ERR_PTR(-2);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct clk *of_clk_get_by_name(struct device_node *np,
>          const char *name)
>{
> return ERR_PTR(-2);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct clk *of_clk_get_from_provider(struct of_phandle_args *clkspec)
>{
> return ERR_PTR(-2);
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_qos.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_qos.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dev_printk.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/dev_printk.h"
>struct device;
>
>
>
>
>struct dev_printk_info {
> char subsystem[16];
> char device[48];
>};
>
>
>
>__attribute__((__format__(printf, 3, 0))) __attribute__((__cold__))
>int dev_vprintk_emit(int level, const struct device *dev,
>       const char *fmt, va_list args);
>__attribute__((__format__(printf, 3, 4))) __attribute__((__cold__))
>int dev_printk_emit(int level, const struct device *dev, const char *fmt, ...);
>
>__attribute__((__format__(printf, 3, 4))) __attribute__((__cold__))
>void dev_printk(const char *level, const struct device *dev,
>  const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_emerg(const struct device *dev, const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_alert(const struct device *dev, const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_crit(const struct device *dev, const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_err(const struct device *dev, const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_warn(const struct device *dev, const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_notice(const struct device *dev, const char *fmt, ...);
>__attribute__((__format__(printf, 2, 3))) __attribute__((__cold__))
>void _dev_info(const struct device *dev, const char *fmt, ...);
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 1
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/cpufreq.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/cpufreq.h"
>struct cpufreq_policy;
>
>struct update_util_data {
>       void (*func)(struct update_util_data *data, u64 time, unsigned int flags);
>};
>
>void cpufreq_add_update_util_hook(int cpu, struct update_util_data *data,
>                       void (*func)(struct update_util_data *data, u64 time,
>        unsigned int flags));
>void cpufreq_remove_update_util_hook(int cpu);
>bool cpufreq_this_cpu_can_update(struct cpufreq_policy *policy);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long map_util_freq(unsigned long util,
>     unsigned long freq, unsigned long cap)
>{
> return freq * util / cap;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long map_util_perf(unsigned long util)
>{
> return util + (util >> 2);
>}
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/idle.h" 1
>
>
>
>
>
>
>enum cpu_idle_type {
> CPU_IDLE,
> CPU_NOT_IDLE,
> CPU_NEWLY_IDLE,
> CPU_MAX_IDLE_TYPES
>};
>
>extern void wake_up_if_idle(int cpu);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __current_set_polling(void)
>{
> set_ti_thread_flag(((struct thread_info *)get_current()), 21);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) current_set_polling_and_test(void)
>{
> __current_set_polling();
>
>
>
>
>
> do { } while (0);
>
> return __builtin_expect(!!(test_ti_thread_flag(((struct thread_info *)get_current()), 3)), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __current_clr_polling(void)
>{
> clear_ti_thread_flag(((struct thread_info *)get_current()), 21);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__warn_unused_result__)) current_clr_polling_and_test(void)
>{
> __current_clr_polling();
>
>
>
>
>
> do { } while (0);
>
> return __builtin_expect(!!(test_ti_thread_flag(((struct thread_info *)get_current()), 3)), 0);
>}
># 72 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/idle.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void current_clr_polling(void)
>{
> __current_clr_polling();
>
>
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
>
> do { if (test_ti_thread_flag(((struct thread_info *)get_current()), 3)) set_preempt_need_resched(); } while (0);
>}
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h" 2
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h"
>enum {
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h" 1
># 51 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_BALANCE_NEWIDLE,
>
>
>
>
>
>
>
>__SD_BALANCE_EXEC,
>
>
>
>
>
>
>
>__SD_BALANCE_FORK,
>
>
>
>
>
>
>
>__SD_BALANCE_WAKE,
>
>
>
>
>
>
>__SD_WAKE_AFFINE,
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_ASYM_CPUCAPACITY,
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_ASYM_CPUCAPACITY_FULL,
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_SHARE_CPUCAPACITY,
># 119 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_SHARE_PKG_RESOURCES,
># 130 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_SERIALIZE,
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_ASYM_PACKING,
># 150 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>__SD_PREFER_SIBLING,
>
>
>
>
>
>
>
>__SD_OVERLAP,
>
>
>
>
>
>
>
>__SD_NUMA,
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h" 2
> __SD_FLAG_CNT,
>};
>
>
>
>enum {
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h" 1
># 51 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_BALANCE_NEWIDLE = 1 << __SD_BALANCE_NEWIDLE,
>
>
>
>
>
>
>
>SD_BALANCE_EXEC = 1 << __SD_BALANCE_EXEC,
>
>
>
>
>
>
>
>SD_BALANCE_FORK = 1 << __SD_BALANCE_FORK,
>
>
>
>
>
>
>
>SD_BALANCE_WAKE = 1 << __SD_BALANCE_WAKE,
>
>
>
>
>
>
>SD_WAKE_AFFINE = 1 << __SD_WAKE_AFFINE,
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_ASYM_CPUCAPACITY = 1 << __SD_ASYM_CPUCAPACITY,
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_ASYM_CPUCAPACITY_FULL = 1 << __SD_ASYM_CPUCAPACITY_FULL,
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_SHARE_CPUCAPACITY = 1 << __SD_SHARE_CPUCAPACITY,
># 119 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_SHARE_PKG_RESOURCES = 1 << __SD_SHARE_PKG_RESOURCES,
># 130 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_SERIALIZE = 1 << __SD_SERIALIZE,
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_ASYM_PACKING = 1 << __SD_ASYM_PACKING,
># 150 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/sd_flags.h"
>SD_PREFER_SIBLING = 1 << __SD_PREFER_SIBLING,
>
>
>
>
>
>
>
>SD_OVERLAP = 1 << __SD_OVERLAP,
>
>
>
>
>
>
>
>SD_NUMA = 1 << __SD_NUMA,
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h" 2
>};
>
>
>
>
>struct sd_flag_debug {
> unsigned int meta_flags;
> char *name;
>};
>extern const struct sd_flag_debug sd_flag_debug[];
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_smt_flags(void)
>{
> return SD_SHARE_CPUCAPACITY | SD_SHARE_PKG_RESOURCES;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_cluster_flags(void)
>{
> return SD_SHARE_PKG_RESOURCES;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_core_flags(void)
>{
> return SD_SHARE_PKG_RESOURCES;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpu_numa_flags(void)
>{
> return SD_NUMA;
>}
>
>
>extern int arch_asym_cpu_priority(int cpu);
>
>struct sched_domain_attr {
> int relax_domain_level;
>};
>
>
>
>
>
>extern int sched_domain_level_max;
>
>struct sched_group;
>
>struct sched_domain_shared {
> atomic_t ref;
> atomic_t nr_busy_cpus;
> int has_idle_cores;
> int nr_idle_scan;
>};
>
>struct sched_domain {
>
> struct sched_domain *parent;
> struct sched_domain *child;
> struct sched_group *groups;
> unsigned long min_interval;
> unsigned long max_interval;
> unsigned int busy_factor;
> unsigned int imbalance_pct;
> unsigned int cache_nice_tries;
> unsigned int imb_numa_nr;
>
> int nohz_idle;
> int flags;
> int level;
>
>
> unsigned long last_balance;
> unsigned int balance_interval;
> unsigned int nr_balance_failed;
>
>
> u64 max_newidle_lb_cost;
> unsigned long next_decay_max_lb_cost;
>
> u64 avg_scan_cost;
>
>
>
> unsigned int lb_count[CPU_MAX_IDLE_TYPES];
> unsigned int lb_failed[CPU_MAX_IDLE_TYPES];
> unsigned int lb_balanced[CPU_MAX_IDLE_TYPES];
> unsigned int lb_imbalance[CPU_MAX_IDLE_TYPES];
> unsigned int lb_gained[CPU_MAX_IDLE_TYPES];
> unsigned int lb_hot_gained[CPU_MAX_IDLE_TYPES];
> unsigned int lb_nobusyg[CPU_MAX_IDLE_TYPES];
> unsigned int lb_nobusyq[CPU_MAX_IDLE_TYPES];
>
>
> unsigned int alb_count;
> unsigned int alb_failed;
> unsigned int alb_pushed;
>
>
> unsigned int sbe_count;
> unsigned int sbe_balanced;
> unsigned int sbe_pushed;
>
>
> unsigned int sbf_count;
> unsigned int sbf_balanced;
> unsigned int sbf_pushed;
>
>
> unsigned int ttwu_wake_remote;
> unsigned int ttwu_move_affine;
> unsigned int ttwu_move_balance;
>
>
> char *name;
>
> union {
>  void *private;
>  struct callback_head rcu;
> };
> struct sched_domain_shared *shared;
>
> unsigned int span_weight;
>
>
>
>
>
>
>
> unsigned long span[];
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cpumask *sched_domain_span(struct sched_domain *sd)
>{
> return ((struct cpumask *)(1 ? (sd->span) : (void *)sizeof(__check_is_bitmap(sd->span))));
>}
>
>extern void partition_sched_domains_locked(int ndoms_new,
>        cpumask_var_t doms_new[],
>        struct sched_domain_attr *dattr_new);
>
>extern void partition_sched_domains(int ndoms_new, cpumask_var_t doms_new[],
>        struct sched_domain_attr *dattr_new);
>
>
>cpumask_var_t *alloc_sched_domains(unsigned int ndoms);
>void free_sched_domains(cpumask_var_t doms[], unsigned int ndoms);
>
>bool cpus_share_cache(int this_cpu, int that_cpu);
>
>typedef const struct cpumask *(*sched_domain_mask_f)(int cpu);
>typedef int (*sched_domain_flags_f)(void);
>
>
>
>struct sd_data {
> struct sched_domain * *sd;
> struct sched_domain_shared * *sds;
> struct sched_group * *sg;
> struct sched_group_capacity * *sgc;
>};
>
>struct sched_domain_topology_level {
> sched_domain_mask_f mask;
> sched_domain_flags_f sd_flags;
> int flags;
> int numa_level;
> struct sd_data data;
>
> char *name;
>
>};
>
>extern void set_sched_topology(struct sched_domain_topology_level *tl);
># 238 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h"
>extern void rebuild_sched_domains_energy(void);
># 256 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/topology.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>unsigned long arch_scale_cpu_capacity(int cpu)
>{
> return (1L << 10);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>unsigned long arch_scale_thermal_pressure(int cpu)
>{
> return 0;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void arch_set_thermal_pressure(const struct cpumask *cpus,
>          unsigned long th_pressure)
>{ }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int task_node(const struct task_struct *p)
>{
> return cpu_to_node(task_cpu(p));
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h" 2
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
>struct em_perf_state {
> unsigned long frequency;
> unsigned long power;
> unsigned long cost;
>};
># 44 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
>struct em_perf_domain {
> struct em_perf_state *table;
> int nr_perf_states;
> int milliwatts;
> unsigned long cpus[];
>};
># 72 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
>struct em_data_callback {
># 92 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
> int (*active_power)(unsigned long *power, unsigned long *freq,
>       struct device *dev);
>};
>
>
>struct em_perf_domain *em_cpu_get(int cpu);
>struct em_perf_domain *em_pd_get(struct device *dev);
>int em_dev_register_perf_domain(struct device *dev, unsigned int nr_states,
>    struct em_data_callback *cb, cpumask_t *span,
>    bool milliwatts);
>void em_dev_unregister_perf_domain(struct device *dev);
># 120 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long em_cpu_energy(struct em_perf_domain *pd,
>    unsigned long max_util, unsigned long sum_util,
>    unsigned long allowed_cpu_cap)
>{
> unsigned long freq, scale_cpu;
> struct em_perf_state *ps;
> int i, cpu;
>
> if (!sum_util)
>  return 0;
># 139 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
> cpu = cpumask_first(((struct cpumask *)(1 ? (pd->cpus) : (void *)sizeof(__check_is_bitmap(pd->cpus)))));
> scale_cpu = arch_scale_cpu_capacity(cpu);
> ps = &pd->table[pd->nr_perf_states - 1];
>
> max_util = map_util_perf(max_util);
> max_util = __builtin_choose_expr(((!!(sizeof((typeof(max_util) *)1 == (typeof(allowed_cpu_cap) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(max_util) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(allowed_cpu_cap) * 0l)) : (int *)8))))), ((max_util) < (allowed_cpu_cap) ? (max_util) : (allowed_cpu_cap)), ({ typeof(max_util) __UNIQUE_ID___x263 = (max_util); typeof(allowed_cpu_cap) __UNIQUE_ID___y264 = (allowed_cpu_cap); ((__UNIQUE_ID___x263) < (__UNIQUE_ID___y264) ? (__UNIQUE_ID___x263) : (__UNIQUE_ID___y264)); }));
> freq = map_util_freq(max_util, ps->frequency, scale_cpu);
>
>
>
>
>
> for (i = 0; i < pd->nr_perf_states; i++) {
>  ps = &pd->table[i];
>  if (ps->frequency >= freq)
>   break;
> }
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
> return ps->cost * sum_util / scale_cpu;
>}
># 209 "/usr/src/linux-5.14.21-150500.53/include/linux/energy_model.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int em_pd_nr_perf_states(struct em_perf_domain *pd)
>{
> return pd->nr_perf_states;
>}
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/klist.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/klist.h"
>struct klist_node;
>struct klist {
> spinlock_t k_lock;
> struct list_head k_list;
> void (*get)(struct klist_node *);
> void (*put)(struct klist_node *);
>} __attribute__ ((aligned (sizeof(void *))));
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/klist.h"
>extern void klist_init(struct klist *k, void (*get)(struct klist_node *),
>         void (*put)(struct klist_node *));
>
>struct klist_node {
> void *n_klist;
> struct list_head n_node;
> struct kref n_ref;
>};
>
>extern void klist_add_tail(struct klist_node *n, struct klist *k);
>extern void klist_add_head(struct klist_node *n, struct klist *k);
>extern void klist_add_behind(struct klist_node *n, struct klist_node *pos);
>extern void klist_add_before(struct klist_node *n, struct klist_node *pos);
>
>extern void klist_del(struct klist_node *n);
>extern void klist_remove(struct klist_node *n);
>
>extern int klist_node_attached(struct klist_node *n);
>
>
>struct klist_iter {
> struct klist *i_klist;
> struct klist_node *i_cur;
>};
>
>
>extern void klist_iter_init(struct klist *k, struct klist_iter *i);
>extern void klist_iter_init_node(struct klist *k, struct klist_iter *i,
>     struct klist_node *n);
>extern void klist_iter_exit(struct klist_iter *i);
>extern struct klist_node *klist_prev(struct klist_iter *i);
>extern struct klist_node *klist_next(struct klist_iter *i);
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>extern void (*pm_power_off)(void);
>extern void (*pm_power_off_prepare)(void);
>
>struct device;
>
>extern void pm_vt_switch_required(struct device *dev, bool required);
>extern void pm_vt_switch_unregister(struct device *dev);
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>extern const char power_group_name[];
>
>
>
>
>typedef struct pm_message {
> int event;
>} pm_message_t;
># 278 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>struct dev_pm_ops {
> int (*prepare)(struct device *dev);
> void (*complete)(struct device *dev);
> int (*suspend)(struct device *dev);
> int (*resume)(struct device *dev);
> int (*freeze)(struct device *dev);
> int (*thaw)(struct device *dev);
> int (*poweroff)(struct device *dev);
> int (*restore)(struct device *dev);
> int (*suspend_late)(struct device *dev);
> int (*resume_early)(struct device *dev);
> int (*freeze_late)(struct device *dev);
> int (*thaw_early)(struct device *dev);
> int (*poweroff_late)(struct device *dev);
> int (*restore_early)(struct device *dev);
> int (*suspend_noirq)(struct device *dev);
> int (*resume_noirq)(struct device *dev);
> int (*freeze_noirq)(struct device *dev);
> int (*thaw_noirq)(struct device *dev);
> int (*poweroff_noirq)(struct device *dev);
> int (*restore_noirq)(struct device *dev);
> int (*runtime_suspend)(struct device *dev);
> int (*runtime_resume)(struct device *dev);
> int (*runtime_idle)(struct device *dev);
>};
># 552 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>enum rpm_status {
> RPM_INVALID = -1,
> RPM_ACTIVE = 0,
> RPM_RESUMING,
> RPM_SUSPENDED,
> RPM_SUSPENDING,
>};
># 575 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>enum rpm_request {
> RPM_REQ_NONE = 0,
> RPM_REQ_IDLE,
> RPM_REQ_SUSPEND,
> RPM_REQ_AUTOSUSPEND,
> RPM_REQ_RESUME,
>};
>
>struct wakeup_source;
>struct wake_irq;
>struct pm_domain_data;
>
>struct pm_subsys_data {
> spinlock_t lock;
> unsigned int refcount;
>
> unsigned int clock_op_might_sleep;
> struct mutex clock_mutex;
> struct list_head clock_list;
>
>
> struct pm_domain_data *domain_data;
>
>};
># 618 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>struct dev_pm_info {
> pm_message_t power_state;
> unsigned int can_wakeup:1;
> unsigned int async_suspend:1;
> bool in_dpm_list:1;
> bool is_prepared:1;
> bool is_suspended:1;
> bool is_noirq_suspended:1;
> bool is_late_suspended:1;
> bool no_pm:1;
> bool early_init:1;
> bool direct_complete:1;
> u32 driver_flags;
> spinlock_t lock;
>
> struct list_head entry;
> struct completion completion;
> struct wakeup_source *wakeup;
> bool wakeup_path:1;
> bool syscore:1;
> bool no_pm_callbacks:1;
> unsigned int must_resume:1;
> unsigned int may_skip_resume:1;
>
>
>
>
> struct hrtimer suspend_timer;
> u64 timer_expires;
> struct work_struct work;
> wait_queue_head_t wait_queue;
> struct wake_irq *wakeirq;
> atomic_t usage_count;
> atomic_t child_count;
> unsigned int disable_depth:3;
> unsigned int idle_notification:1;
> unsigned int request_pending:1;
> unsigned int deferred_resume:1;
> unsigned int needs_force_resume: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;
> unsigned int links_count;
> enum rpm_request request;
> enum rpm_status runtime_status;
> enum rpm_status last_status;
> int runtime_error;
> int autosuspend_delay;
> u64 last_busy;
> u64 active_time;
> u64 suspended_time;
> u64 accounting_timestamp;
>
> struct pm_subsys_data *subsys_data;
> void (*set_latency_tolerance)(struct device *, s32);
> struct dev_pm_qos *qos;
>};
>
>extern int dev_pm_get_subsys_data(struct device *dev);
>extern void dev_pm_put_subsys_data(struct device *dev);
># 697 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>struct dev_pm_domain {
> struct dev_pm_ops ops;
> int (*start)(struct device *dev);
> void (*detach)(struct device *dev, bool power_off);
> int (*activate)(struct device *dev);
> void (*sync)(struct device *dev);
> void (*dismiss)(struct device *dev);
>};
># 761 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>extern void device_pm_lock(void);
>extern void dpm_resume_start(pm_message_t state);
>extern void dpm_resume_end(pm_message_t state);
>extern void dpm_resume_noirq(pm_message_t state);
>extern void dpm_resume_early(pm_message_t state);
>extern void dpm_resume(pm_message_t state);
>extern void dpm_complete(pm_message_t state);
>
>extern void device_pm_unlock(void);
>extern int dpm_suspend_end(pm_message_t state);
>extern int dpm_suspend_start(pm_message_t state);
>extern int dpm_suspend_noirq(pm_message_t state);
>extern int dpm_suspend_late(pm_message_t state);
>extern int dpm_suspend(pm_message_t state);
>extern int dpm_prepare(pm_message_t state);
>
>extern void __suspend_report_result(const char *function, struct device *dev, void *fn, int ret);
>
>
>
>
>
>
>extern int device_pm_wait_for_dev(struct device *sub, struct device *dev);
>extern void dpm_for_each_dev(void *data, void (*fn)(struct device *, void *));
>
>extern int pm_generic_prepare(struct device *dev);
>extern int pm_generic_suspend_late(struct device *dev);
>extern int pm_generic_suspend_noirq(struct device *dev);
>extern int pm_generic_suspend(struct device *dev);
>extern int pm_generic_resume_early(struct device *dev);
>extern int pm_generic_resume_noirq(struct device *dev);
>extern int pm_generic_resume(struct device *dev);
>extern int pm_generic_freeze_noirq(struct device *dev);
>extern int pm_generic_freeze_late(struct device *dev);
>extern int pm_generic_freeze(struct device *dev);
>extern int pm_generic_thaw_noirq(struct device *dev);
>extern int pm_generic_thaw_early(struct device *dev);
>extern int pm_generic_thaw(struct device *dev);
>extern int pm_generic_restore_noirq(struct device *dev);
>extern int pm_generic_restore_early(struct device *dev);
>extern int pm_generic_restore(struct device *dev);
>extern int pm_generic_poweroff_noirq(struct device *dev);
>extern int pm_generic_poweroff_late(struct device *dev);
>extern int pm_generic_poweroff(struct device *dev);
>extern void pm_generic_complete(struct device *dev);
>
>extern bool dev_pm_skip_resume(struct device *dev);
>extern bool dev_pm_skip_suspend(struct device *dev);
># 855 "/usr/src/linux-5.14.21-150500.53/include/linux/pm.h"
>enum dpm_order {
> DPM_ORDER_NONE,
> DPM_ORDER_DEV_AFTER_PARENT,
> DPM_ORDER_PARENT_BEFORE_DEV,
> DPM_ORDER_DEV_LAST,
>};
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/device/bus.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/device/bus.h"
>struct device_driver;
>struct fwnode_handle;
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/device/bus.h"
>struct bus_type {
> const char *name;
> const char *dev_name;
> struct device *dev_root;
> const struct attribute_group **bus_groups;
> const struct attribute_group **dev_groups;
> const struct attribute_group **drv_groups;
>
> int (*match)(struct device *dev, struct device_driver *drv);
> int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
> int (*probe)(struct device *dev);
> void (*sync_state)(struct device *dev);
> void (*remove)(struct device *dev);
> void (*shutdown)(struct device *dev);
>
> int (*online)(struct device *dev);
> int (*offline)(struct device *dev);
>
> int (*suspend)(struct device *dev, pm_message_t state);
> int (*resume)(struct device *dev);
>
> int (*num_vf)(struct device *dev);
>
> int (*dma_configure)(struct device *dev);
> void (*dma_cleanup)(struct device *dev);
>
> const struct dev_pm_ops *pm;
>
> const struct iommu_ops *iommu_ops;
>
> struct subsys_private *p;
> struct lock_class_key lock_key;
>
> bool need_parent_lock;
>
> void *suse_kabi_padding;
>};
>
>extern int __attribute__((__warn_unused_result__)) bus_register(struct bus_type *bus);
>
>extern void bus_unregister(struct bus_type *bus);
>
>extern int __attribute__((__warn_unused_result__)) bus_rescan_devices(struct bus_type *bus);
>
>struct bus_attribute {
> struct attribute attr;
> ssize_t (*show)(struct bus_type *bus, char *buf);
> ssize_t (*store)(struct bus_type *bus, const char *buf, size_t count);
>};
># 141 "/usr/src/linux-5.14.21-150500.53/include/linux/device/bus.h"
>extern int __attribute__((__warn_unused_result__)) bus_create_file(struct bus_type *,
>     struct bus_attribute *);
>extern void bus_remove_file(struct bus_type *, struct bus_attribute *);
>
>
>int device_match_name(struct device *dev, const void *name);
>int device_match_of_node(struct device *dev, const void *np);
>int device_match_fwnode(struct device *dev, const void *fwnode);
>int device_match_devt(struct device *dev, const void *pdevt);
>int device_match_acpi_dev(struct device *dev, const void *adev);
>int device_match_any(struct device *dev, const void *unused);
>
>
>struct subsys_dev_iter {
> struct klist_iter ki;
> const struct device_type *type;
>};
>void subsys_dev_iter_init(struct subsys_dev_iter *iter,
>    struct bus_type *subsys,
>    struct device *start,
>    const struct device_type *type);
>struct device *subsys_dev_iter_next(struct subsys_dev_iter *iter);
>void subsys_dev_iter_exit(struct subsys_dev_iter *iter);
>
>int bus_for_each_dev(struct bus_type *bus, struct device *start, void *data,
>       int (*fn)(struct device *dev, void *data));
>struct device *bus_find_device(struct bus_type *bus, struct device *start,
>          const void *data,
>          int (*match)(struct device *dev, const void *data));
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *bus_find_device_by_name(struct bus_type *bus,
>           struct device *start,
>           const char *name)
>{
> return bus_find_device(bus, start, name, device_match_name);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>bus_find_device_by_of_node(struct bus_type *bus, const struct device_node *np)
>{
> return bus_find_device(bus, ((void *)0), np, device_match_of_node);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>bus_find_device_by_fwnode(struct bus_type *bus, const struct fwnode_handle *fwnode)
>{
> return bus_find_device(bus, ((void *)0), fwnode, device_match_fwnode);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *bus_find_device_by_devt(struct bus_type *bus,
>           dev_t devt)
>{
> return bus_find_device(bus, ((void *)0), &devt, device_match_devt);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>bus_find_next_device(struct bus_type *bus,struct device *cur)
>{
> return bus_find_device(bus, cur, ((void *)0), device_match_any);
>}
>
>
>struct acpi_device;
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>bus_find_device_by_acpi_dev(struct bus_type *bus, const struct acpi_device *adev)
>{
> return bus_find_device(bus, ((void *)0), adev, device_match_acpi_dev);
>}
># 254 "/usr/src/linux-5.14.21-150500.53/include/linux/device/bus.h"
>struct device *subsys_find_device_by_id(struct bus_type *bus, unsigned int id,
>     struct device *hint);
>int bus_for_each_drv(struct bus_type *bus, struct device_driver *start,
>       void *data, int (*fn)(struct device_driver *, void *));
>void bus_sort_breadthfirst(struct bus_type *bus,
>      int (*compare)(const struct device *a,
>       const struct device *b));
>
>
>
>
>
>
>struct notifier_block;
>
>extern int bus_register_notifier(struct bus_type *bus,
>     struct notifier_block *nb);
>extern int bus_unregister_notifier(struct bus_type *bus,
>       struct notifier_block *nb);
># 290 "/usr/src/linux-5.14.21-150500.53/include/linux/device/bus.h"
>extern struct kset *bus_get_kset(struct bus_type *bus);
>extern struct klist *bus_get_device_klist(struct bus_type *bus);
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h"
>struct device;
>struct fwnode_handle;
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h"
>struct class {
> const char *name;
> struct module *owner;
>
> const struct attribute_group **class_groups;
> const struct attribute_group **dev_groups;
> struct kobject *dev_kobj;
>
> int (*dev_uevent)(struct device *dev, struct kobj_uevent_env *env);
> char *(*devnode)(struct device *dev, umode_t *mode);
>
> void (*class_release)(struct class *class);
> void (*dev_release)(struct device *dev);
>
> int (*shutdown_pre)(struct device *dev);
>
> const struct kobj_ns_type_operations *ns_type;
> const void *(*namespace)(struct device *dev);
>
> void (*get_ownership)(struct device *dev, kuid_t *uid, kgid_t *gid);
>
> const struct dev_pm_ops *pm;
>
> struct subsys_private *p;
>
> void *suse_kabi_padding;
>};
>
>struct class_dev_iter {
> struct klist_iter ki;
> const struct device_type *type;
>};
>
>extern struct kobject *sysfs_dev_block_kobj;
>extern struct kobject *sysfs_dev_char_kobj;
>extern int __attribute__((__warn_unused_result__)) __class_register(struct class *class,
>      struct lock_class_key *key);
>extern void class_unregister(struct class *class);
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h"
>struct class_compat;
>struct class_compat *class_compat_register(const char *name);
>void class_compat_unregister(struct class_compat *cls);
>int class_compat_create_link(struct class_compat *cls, struct device *dev,
>        struct device *device_link);
>void class_compat_remove_link(struct class_compat *cls, struct device *dev,
>         struct device *device_link);
>
>extern void class_dev_iter_init(struct class_dev_iter *iter,
>    struct class *class,
>    struct device *start,
>    const struct device_type *type);
>extern struct device *class_dev_iter_next(struct class_dev_iter *iter);
>extern void class_dev_iter_exit(struct class_dev_iter *iter);
>
>extern int class_for_each_device(struct class *class, struct device *start,
>     void *data,
>     int (*fn)(struct device *dev, void *data));
>extern struct device *class_find_device(struct class *class,
>     struct device *start, const void *data,
>     int (*match)(struct device *, const void *));
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *class_find_device_by_name(struct class *class,
>             const char *name)
>{
> return class_find_device(class, ((void *)0), name, device_match_name);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>class_find_device_by_of_node(struct class *class, const struct device_node *np)
>{
> return class_find_device(class, ((void *)0), np, device_match_of_node);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>class_find_device_by_fwnode(struct class *class,
>       const struct fwnode_handle *fwnode)
>{
> return class_find_device(class, ((void *)0), fwnode, device_match_fwnode);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *class_find_device_by_devt(struct class *class,
>             dev_t devt)
>{
> return class_find_device(class, ((void *)0), &devt, device_match_devt);
>}
>
>
>struct acpi_device;
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>class_find_device_by_acpi_dev(struct class *class, const struct acpi_device *adev)
>{
> return class_find_device(class, ((void *)0), adev, device_match_acpi_dev);
>}
># 193 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h"
>struct class_attribute {
> struct attribute attr;
> ssize_t (*show)(struct class *class, struct class_attribute *attr,
>   char *buf);
> ssize_t (*store)(struct class *class, struct class_attribute *attr,
>   const char *buf, size_t count);
>};
># 208 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h"
>extern int __attribute__((__warn_unused_result__)) class_create_file_ns(struct class *class,
>          const struct class_attribute *attr,
>          const void *ns);
>extern void class_remove_file_ns(struct class *class,
>     const struct class_attribute *attr,
>     const void *ns);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) class_create_file(struct class *class,
>     const struct class_attribute *attr)
>{
> return class_create_file_ns(class, attr, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void class_remove_file(struct class *class,
>         const struct class_attribute *attr)
>{
> return class_remove_file_ns(class, attr, ((void *)0));
>}
>
>
>struct class_attribute_string {
> struct class_attribute attr;
> char *str;
>};
># 240 "/usr/src/linux-5.14.21-150500.53/include/linux/device/class.h"
>extern ssize_t show_class_attr_string(struct class *class, struct class_attribute *attr,
>                        char *buf);
>
>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 *);
>};
>
>extern int __attribute__((__warn_unused_result__)) class_interface_register(struct class_interface *);
>extern void class_interface_unregister(struct class_interface *);
>
>extern struct class * __attribute__((__warn_unused_result__)) __class_create(struct module *owner,
>        const char *name,
>        struct lock_class_key *key);
>extern void class_destroy(struct class *cls);
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/device/driver.h" 1
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/device/driver.h"
>enum probe_type {
> PROBE_DEFAULT_STRATEGY,
> PROBE_PREFER_ASYNCHRONOUS,
> PROBE_FORCE_SYNCHRONOUS,
>};
># 96 "/usr/src/linux-5.14.21-150500.53/include/linux/device/driver.h"
>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 *dev);
> void (*sync_state)(struct device *dev);
> int (*remove) (struct device *dev);
> void (*shutdown) (struct device *dev);
> int (*suspend) (struct device *dev, pm_message_t state);
> int (*resume) (struct device *dev);
> const struct attribute_group **groups;
> const struct attribute_group **dev_groups;
>
> const struct dev_pm_ops *pm;
> void (*coredump) (struct device *dev);
>
> struct driver_private *p;
>
> void *suse_kabi_padding;
>};
>
>
>extern int __attribute__((__warn_unused_result__)) driver_register(struct device_driver *drv);
>extern void driver_unregister(struct device_driver *drv);
>
>extern struct device_driver *driver_find(const char *name,
>      struct bus_type *bus);
>extern int driver_probe_done(void);
>extern void wait_for_device_probe(void);
>
>
>
>struct driver_attribute {
> struct attribute attr;
> ssize_t (*show)(struct device_driver *driver, char *buf);
> ssize_t (*store)(struct device_driver *driver, const char *buf,
>    size_t count);
>};
># 151 "/usr/src/linux-5.14.21-150500.53/include/linux/device/driver.h"
>extern int __attribute__((__warn_unused_result__)) driver_create_file(struct device_driver *driver,
>     const struct driver_attribute *attr);
>extern void driver_remove_file(struct device_driver *driver,
>          const struct driver_attribute *attr);
>
>int driver_set_override(struct device *dev, const char **override,
>   const char *s, size_t len);
>extern int __attribute__((__warn_unused_result__)) driver_for_each_device(struct device_driver *drv,
>            struct device *start,
>            void *data,
>            int (*fn)(struct device *dev,
>        void *));
>struct device *driver_find_device(struct device_driver *drv,
>      struct device *start, const void *data,
>      int (*match)(struct device *dev, const void *data));
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *driver_find_device_by_name(struct device_driver *drv,
>       const char *name)
>{
> return driver_find_device(drv, ((void *)0), name, device_match_name);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>driver_find_device_by_of_node(struct device_driver *drv,
>         const struct device_node *np)
>{
> return driver_find_device(drv, ((void *)0), np, device_match_of_node);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>driver_find_device_by_fwnode(struct device_driver *drv,
>        const struct fwnode_handle *fwnode)
>{
> return driver_find_device(drv, ((void *)0), fwnode, device_match_fwnode);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *driver_find_device_by_devt(struct device_driver *drv,
>       dev_t devt)
>{
> return driver_find_device(drv, ((void *)0), &devt, device_match_devt);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *driver_find_next_device(struct device_driver *drv,
>           struct device *start)
>{
> return driver_find_device(drv, start, ((void *)0), device_match_any);
>}
># 230 "/usr/src/linux-5.14.21-150500.53/include/linux/device/driver.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *
>driver_find_device_by_acpi_dev(struct device_driver *drv,
>          const struct acpi_device *adev)
>{
> return driver_find_device(drv, ((void *)0), adev, device_match_acpi_dev);
>}
># 244 "/usr/src/linux-5.14.21-150500.53/include/linux/device/driver.h"
>extern int driver_deferred_probe_timeout;
>void driver_deferred_probe_add(struct device *dev);
>int driver_deferred_probe_check_state(struct device *dev);
>void driver_init(void);
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/device.h" 1
>
>
>
>
>struct dev_archdata {
>};
>
>struct pdev_archdata {
>};
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
>
>struct device;
>struct device_private;
>struct device_driver;
>struct driver_private;
>struct module;
>struct class;
>struct subsys_private;
>struct device_node;
>struct fwnode_handle;
>struct iommu_ops;
>struct iommu_group;
>struct dev_pin_info;
>struct dev_iommu;
># 62 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>struct subsys_interface {
> const char *name;
> struct bus_type *subsys;
> struct list_head node;
> int (*add_dev)(struct device *dev, struct subsys_interface *sif);
> void (*remove_dev)(struct device *dev, struct subsys_interface *sif);
>};
>
>int subsys_interface_register(struct subsys_interface *sif);
>void subsys_interface_unregister(struct subsys_interface *sif);
>
>int subsys_system_register(struct bus_type *subsys,
>      const struct attribute_group **groups);
>int subsys_virtual_register(struct bus_type *subsys,
>       const struct attribute_group **groups);
># 87 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>struct device_type {
> const char *name;
> const struct attribute_group **groups;
> int (*uevent)(struct device *dev, struct kobj_uevent_env *env);
> char *(*devnode)(struct device *dev, umode_t *mode,
>    kuid_t *uid, kgid_t *gid);
> void (*release)(struct device *dev);
>
> const struct dev_pm_ops *pm;
>};
>
>
>struct device_attribute {
> struct attribute attr;
> ssize_t (*show)(struct device *dev, struct device_attribute *attr,
>   char *buf);
> ssize_t (*store)(struct device *dev, struct device_attribute *attr,
>    const char *buf, size_t count);
>};
>
>struct dev_ext_attribute {
> struct device_attribute attr;
> void *var;
>};
>
>ssize_t device_show_ulong(struct device *dev, struct device_attribute *attr,
>     char *buf);
>ssize_t device_store_ulong(struct device *dev, struct device_attribute *attr,
>      const char *buf, size_t count);
>ssize_t device_show_int(struct device *dev, struct device_attribute *attr,
>   char *buf);
>ssize_t device_store_int(struct device *dev, struct device_attribute *attr,
>    const char *buf, size_t count);
>ssize_t device_show_bool(struct device *dev, struct device_attribute *attr,
>   char *buf);
>ssize_t device_store_bool(struct device *dev, struct device_attribute *attr,
>    const char *buf, size_t count);
># 153 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>int device_create_file(struct device *device,
>         const struct device_attribute *entry);
>void device_remove_file(struct device *dev,
>   const struct device_attribute *attr);
>bool device_remove_file_self(struct device *dev,
>        const struct device_attribute *attr);
>int __attribute__((__warn_unused_result__)) device_create_bin_file(struct device *dev,
>     const struct bin_attribute *attr);
>void device_remove_bin_file(struct device *dev,
>       const struct bin_attribute *attr);
>
>
>typedef void (*dr_release_t)(struct device *dev, void *res);
>typedef int (*dr_match_t)(struct device *dev, void *res, void *match_data);
>
>void *__devres_alloc_node(dr_release_t release, size_t size, gfp_t gfp,
>     int nid, const char *name) __attribute__((__malloc__));
>
>
>
>
>
>void devres_for_each_res(struct device *dev, dr_release_t release,
>    dr_match_t match, void *match_data,
>    void (*fn)(struct device *, void *, void *),
>    void *data);
>void devres_free(void *res);
>void devres_add(struct device *dev, void *res);
>void *devres_find(struct device *dev, dr_release_t release,
>    dr_match_t match, void *match_data);
>void *devres_get(struct device *dev, void *new_res,
>   dr_match_t match, void *match_data);
>void *devres_remove(struct device *dev, dr_release_t release,
>      dr_match_t match, void *match_data);
>int devres_destroy(struct device *dev, dr_release_t release,
>     dr_match_t match, void *match_data);
>int devres_release(struct device *dev, dr_release_t release,
>     dr_match_t match, void *match_data);
>
>
>void * __attribute__((__warn_unused_result__)) devres_open_group(struct device *dev, void *id, gfp_t gfp);
>void devres_close_group(struct device *dev, void *id);
>void devres_remove_group(struct device *dev, void *id);
>int devres_release_group(struct device *dev, void *id);
>
>
>void *devm_kmalloc(struct device *dev, size_t size, gfp_t gfp) __attribute__((__malloc__));
>void *devm_krealloc(struct device *dev, void *ptr, size_t size,
>      gfp_t gfp) __attribute__((__warn_unused_result__));
>__attribute__((__format__(printf, 3, 0))) char *devm_kvasprintf(struct device *dev, gfp_t gfp,
>         const char *fmt, va_list ap) __attribute__((__malloc__));
>__attribute__((__format__(printf, 3, 4))) char *devm_kasprintf(struct device *dev, gfp_t gfp,
>        const char *fmt, ...) __attribute__((__malloc__));
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *devm_kzalloc(struct device *dev, size_t size, gfp_t gfp)
>{
> return devm_kmalloc(dev, size, gfp | (( gfp_t)0x100u));
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *devm_kmalloc_array(struct device *dev,
>           size_t n, size_t size, gfp_t flags)
>{
> size_t bytes;
>
> if (__builtin_expect(!!(__must_check_overflow(({ typeof(n) __a = (n); typeof(size) __b = (size); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_mul_overflow(__a, __b, __d); }))), 0))
>  return ((void *)0);
>
> return devm_kmalloc(dev, bytes, flags);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *devm_kcalloc(struct device *dev,
>     size_t n, size_t size, gfp_t flags)
>{
> return devm_kmalloc_array(dev, n, size, flags | (( gfp_t)0x100u));
>}
>void devm_kfree(struct device *dev, const void *p);
>char *devm_kstrdup(struct device *dev, const char *s, gfp_t gfp) __attribute__((__malloc__));
>const char *devm_kstrdup_const(struct device *dev, const char *s, gfp_t gfp);
>void *devm_kmemdup(struct device *dev, const void *src, size_t len, gfp_t gfp);
>
>unsigned long devm_get_free_pages(struct device *dev,
>      gfp_t gfp_mask, unsigned int order);
>void devm_free_pages(struct device *dev, unsigned long addr);
>
>void *devm_ioremap_resource(struct device *dev,
>        const struct resource *res);
>void *devm_ioremap_resource_wc(struct device *dev,
>           const struct resource *res);
>
>void *devm_of_iomap(struct device *dev,
>       struct device_node *node, int index,
>       resource_size_t *size);
>
>
>int devm_add_action(struct device *dev, void (*action)(void *), void *data);
>void devm_remove_action(struct device *dev, void (*action)(void *), void *data);
>void devm_release_action(struct device *dev, void (*action)(void *), void *data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int devm_add_action_or_reset(struct device *dev,
>        void (*action)(void *), void *data)
>{
> int ret;
>
> ret = devm_add_action(dev, action, data);
> if (ret)
>  action(data);
>
> return ret;
>}
># 275 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>void *__devm_alloc_percpu(struct device *dev, size_t size,
>       size_t align);
>void devm_free_percpu(struct device *dev, void *pdata);
>
>struct device_dma_parameters {
>
>
>
>
> unsigned int max_segment_size;
> unsigned int min_align_mask;
> unsigned long segment_boundary_mask;
>};
># 298 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>enum device_link_state {
> DL_STATE_NONE = -1,
> DL_STATE_DORMANT = 0,
> DL_STATE_AVAILABLE,
> DL_STATE_CONSUMER_PROBE,
> DL_STATE_ACTIVE,
> DL_STATE_SUPPLIER_UNBIND,
>};
># 337 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>enum dl_dev_state {
> DL_DEV_NO_DRIVER = 0,
> DL_DEV_PROBING,
> DL_DEV_DRIVER_BOUND,
> DL_DEV_UNBINDING,
>};
># 353 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>enum device_removable {
> DEVICE_REMOVABLE_NOT_SUPPORTED = 0,
> DEVICE_REMOVABLE_UNKNOWN,
> DEVICE_FIXED,
> DEVICE_REMOVABLE,
>};
># 367 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>struct dev_links_info {
> struct list_head suppliers;
> struct list_head consumers;
> struct list_head defer_sync;
> enum dl_dev_state status;
>};
># 473 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>struct device {
> struct kobject kobj;
> struct device *parent;
>
> struct device_private *p;
>
> const char *init_name;
> const struct device_type *type;
>
> struct bus_type *bus;
> struct device_driver *driver;
>
> void *platform_data;
>
> void *driver_data;
>
>
>
>
> struct mutex mutex;
>
>
>
> struct dev_links_info links;
> struct dev_pm_info power;
> struct dev_pm_domain *pm_domain;
>
>
> struct em_perf_domain *em_pd;
>
>
>
> struct irq_domain *msi_domain;
>
>
> struct dev_pin_info *pins;
>
>
> raw_spinlock_t msi_lock;
> struct list_head msi_list;
>
>
> const struct dma_map_ops *dma_ops;
>
> u64 *dma_mask;
> u64 coherent_dma_mask;
>
>
>
>
> u64 bus_dma_limit;
> const struct bus_dma_region *dma_range_map;
>
> struct device_dma_parameters *dma_parms;
>
> struct list_head dma_pools;
>
>
>
>
>
>
> struct cma *cma_area;
>
>
>
> struct io_tlb_mem *dma_io_tlb_mem;
>
>
> struct dev_archdata archdata;
>
> struct device_node *of_node;
> struct fwnode_handle *fwnode;
>
>
> int numa_node;
>
> dev_t devt;
> u32 id;
>
> spinlock_t devres_lock;
> struct list_head devres_head;
>
> struct class *class;
> const struct attribute_group **groups;
>
> void (*release)(struct device *dev);
> struct iommu_group *iommu_group;
> struct dev_iommu *iommu;
>
> enum device_removable removable;
>
> bool offline_disabled:1;
> bool offline:1;
> bool of_node_reused:1;
> bool state_synced:1;
> bool can_match:1;
># 578 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
> void *suse_kabi_padding;
>};
># 595 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>struct device_link {
> struct device *supplier;
> struct list_head s_node;
> struct device *consumer;
> struct list_head c_node;
> struct device link_dev;
> enum device_link_state status;
> u32 flags;
> refcount_t rpm_active;
> struct kref kref;
> struct work_struct rm_work;
> bool supplier_preactivated;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device *kobj_to_dev(struct kobject *kobj)
>{
> return ({ void *__mptr = (void *)(kobj); do { extern void __compiletime_assert_265(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(kobj)), typeof(((struct device *)0)->kobj)) && !__builtin_types_compatible_p(typeof(*(kobj)), typeof(void))))) __compiletime_assert_265(); } while (0); ((struct device *)(__mptr - __builtin_offsetof(struct device, kobj))); });
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_iommu_mapped(struct device *dev)
>{
> return (dev->iommu_group != ((void *)0));
>}
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_wakeup.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_wakeup.h"
>struct wake_irq;
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_wakeup.h"
>struct wakeup_source {
> const char *name;
> int id;
> struct list_head entry;
> spinlock_t lock;
> struct wake_irq *wakeirq;
> struct timer_list timer;
> unsigned long timer_expires;
> ktime_t total_time;
> ktime_t max_time;
> ktime_t last_time;
> ktime_t start_prevent_time;
> ktime_t prevent_sleep_time;
> unsigned long event_count;
> unsigned long active_count;
> unsigned long relax_count;
> unsigned long expire_count;
> unsigned long wakeup_count;
> struct device *dev;
> bool active:1;
> bool autosleep_enabled:1;
>};
># 77 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_wakeup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_can_wakeup(struct device *dev)
>{
> return dev->power.can_wakeup;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_may_wakeup(struct device *dev)
>{
> return dev->power.can_wakeup && !!dev->power.wakeup;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_wakeup_path(struct device *dev)
>{
> return dev->power.wakeup_path;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_set_wakeup_path(struct device *dev)
>{
> dev->power.wakeup_path = true;
>}
>
>
>extern struct wakeup_source *wakeup_source_create(const char *name);
>extern void wakeup_source_destroy(struct wakeup_source *ws);
>extern void wakeup_source_add(struct wakeup_source *ws);
>extern void wakeup_source_remove(struct wakeup_source *ws);
>extern struct wakeup_source *wakeup_source_register(struct device *dev,
>          const char *name);
>extern void wakeup_source_unregister(struct wakeup_source *ws);
>extern int wakeup_sources_read_lock(void);
>extern void wakeup_sources_read_unlock(int idx);
>extern struct wakeup_source *wakeup_sources_walk_start(void);
>extern struct wakeup_source *wakeup_sources_walk_next(struct wakeup_source *ws);
>extern int device_wakeup_enable(struct device *dev);
>extern int device_wakeup_disable(struct device *dev);
>extern void device_set_wakeup_capable(struct device *dev, bool capable);
>extern int device_init_wakeup(struct device *dev, bool val);
>extern int device_set_wakeup_enable(struct device *dev, bool enable);
>extern void __pm_stay_awake(struct wakeup_source *ws);
>extern void pm_stay_awake(struct device *dev);
>extern void __pm_relax(struct wakeup_source *ws);
>extern void pm_relax(struct device *dev);
>extern void pm_wakeup_ws_event(struct wakeup_source *ws, unsigned int msec, bool hard);
>extern void pm_wakeup_dev_event(struct device *dev, unsigned int msec, bool hard);
># 205 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_wakeup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __pm_wakeup_event(struct wakeup_source *ws, unsigned int msec)
>{
> return pm_wakeup_ws_event(ws, msec, false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pm_wakeup_event(struct device *dev, unsigned int msec)
>{
> return pm_wakeup_dev_event(dev, msec, false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pm_wakeup_hard_event(struct device *dev)
>{
> return pm_wakeup_dev_event(dev, 0, true);
>}
># 626 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h" 2
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *dev_name(const struct device *dev)
>{
>
> if (dev->init_name)
>  return dev->init_name;
>
> return kobject_name(&dev->kobj);
>}
># 643 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *dev_bus_name(const struct device *dev)
>{
> return dev->bus ? dev->bus->name : (dev->class ? dev->class->name : "");
>}
>
>__attribute__((__format__(printf, 2, 3))) int dev_set_name(struct device *dev, const char *name, ...);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dev_to_node(struct device *dev)
>{
> return dev->numa_node;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_dev_node(struct device *dev, int node)
>{
> dev->numa_node = node;
>}
># 669 "/usr/src/linux-5.14.21-150500.53/include/linux/device.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *dev_get_msi_domain(const struct device *dev)
>{
>
> return dev->msi_domain;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dev_set_msi_domain(struct device *dev, struct irq_domain *d)
>{
>
> dev->msi_domain = d;
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dev_get_drvdata(const struct device *dev)
>{
> return dev->driver_data;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dev_set_drvdata(struct device *dev, void *data)
>{
> dev->driver_data = data;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pm_subsys_data *dev_to_psd(struct device *dev)
>{
> return dev ? dev->power.subsys_data : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int dev_get_uevent_suppress(const struct device *dev)
>{
> return dev->kobj.uevent_suppress;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dev_set_uevent_suppress(struct device *dev, int val)
>{
> dev->kobj.uevent_suppress = val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_is_registered(struct device *dev)
>{
> return dev->kobj.state_in_sysfs;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_enable_async_suspend(struct device *dev)
>{
> if (!dev->power.is_prepared)
>  dev->power.async_suspend = true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_disable_async_suspend(struct device *dev)
>{
> if (!dev->power.is_prepared)
>  dev->power.async_suspend = false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_async_suspend_enabled(struct device *dev)
>{
> return !!dev->power.async_suspend;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_pm_not_required(struct device *dev)
>{
> return dev->power.no_pm;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_set_pm_not_required(struct device *dev)
>{
> dev->power.no_pm = true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dev_pm_syscore_device(struct device *dev, bool val)
>{
>
> dev->power.syscore = val;
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dev_pm_set_driver_flags(struct device *dev, u32 flags)
>{
> dev->power.driver_flags = flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dev_pm_test_driver_flags(struct device *dev, u32 flags)
>{
> return !!(dev->power.driver_flags & flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_lock(struct device *dev)
>{
> mutex_lock(&dev->mutex);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_lock_interruptible(struct device *dev)
>{
> return mutex_lock_interruptible(&dev->mutex);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_trylock(struct device *dev)
>{
> return mutex_trylock(&dev->mutex);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_unlock(struct device *dev)
>{
> mutex_unlock(&dev->mutex);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_lock_assert(struct device *dev)
>{
> do { (void)(&dev->mutex); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *dev_of_node(struct device *dev)
>{
> if (!0 || !dev)
>  return ((void *)0);
> return dev->of_node;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dev_has_sync_state(struct device *dev)
>{
> if (!dev)
>  return false;
> if (dev->driver && dev->driver->sync_state)
>  return true;
> if (dev->bus && dev->bus->sync_state)
>  return true;
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dev_set_removable(struct device *dev,
>         enum device_removable removable)
>{
> dev->removable = removable;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dev_is_removable(struct device *dev)
>{
> return dev->removable == DEVICE_REMOVABLE;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dev_removable_is_valid(struct device *dev)
>{
> return dev->removable != DEVICE_REMOVABLE_NOT_SUPPORTED;
>}
>
>
>
>
>int __attribute__((__warn_unused_result__)) device_register(struct device *dev);
>void device_unregister(struct device *dev);
>void device_initialize(struct device *dev);
>int __attribute__((__warn_unused_result__)) device_add(struct device *dev);
>void device_del(struct device *dev);
>int device_for_each_child(struct device *dev, void *data,
>     int (*fn)(struct device *dev, void *data));
>int device_for_each_child_reverse(struct device *dev, void *data,
>      int (*fn)(struct device *dev, void *data));
>struct device *device_find_child(struct device *dev, void *data,
>     int (*match)(struct device *dev, void *data));
>struct device *device_find_child_by_name(struct device *parent,
>      const char *name);
>int device_rename(struct device *dev, const char *new_name);
>int device_move(struct device *dev, struct device *new_parent,
>  enum dpm_order dpm_order);
>int device_change_owner(struct device *dev, kuid_t kuid, kgid_t kgid);
>const char *device_get_devnode(struct device *dev, umode_t *mode, kuid_t *uid,
>          kgid_t *gid, const char **tmp);
>int device_is_dependent(struct device *dev, void *target);
>void dev_enable_async_probe(struct device *dev, bool enabled);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_supports_offline(struct device *dev)
>{
> return dev->bus && dev->bus->offline && dev->bus->online;
>}
>
>void lock_device_hotplug(void);
>void unlock_device_hotplug(void);
>int lock_device_hotplug_sysfs(void);
>int device_offline(struct device *dev);
>int device_online(struct device *dev);
>void set_primary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
>void set_secondary_fwnode(struct device *dev, struct fwnode_handle *fwnode);
>void device_set_of_node_from_dev(struct device *dev, const struct device *dev2);
>void device_set_node(struct device *dev, struct fwnode_handle *fwnode);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dev_num_vf(struct device *dev)
>{
> if (dev->bus && dev->bus->num_vf)
>  return dev->bus->num_vf(dev);
> return 0;
>}
>
>
>
>
>struct device *__root_device_register(const char *name, struct module *owner);
>
>
>
>
>
>void root_device_unregister(struct device *root);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dev_get_platdata(const struct device *dev)
>{
> return dev->platform_data;
>}
>
>
>
>
>
>int __attribute__((__warn_unused_result__)) device_driver_attach(struct device_driver *drv,
>          struct device *dev);
>int __attribute__((__warn_unused_result__)) device_bind_driver(struct device *dev);
>void device_release_driver(struct device *dev);
>int __attribute__((__warn_unused_result__)) device_attach(struct device *dev);
>int __attribute__((__warn_unused_result__)) driver_attach(struct device_driver *drv);
>void device_initial_probe(struct device *dev);
>int __attribute__((__warn_unused_result__)) device_reprobe(struct device *dev);
>
>bool device_is_bound(struct device *dev);
>
>
>
>
>__attribute__((__format__(printf, 5, 6))) struct device *
>device_create(struct class *cls, struct device *parent, dev_t devt,
>       void *drvdata, const char *fmt, ...);
>__attribute__((__format__(printf, 6, 7))) struct device *
>device_create_with_groups(struct class *cls, struct device *parent, dev_t devt,
>     void *drvdata, const struct attribute_group **groups,
>     const char *fmt, ...);
>void device_destroy(struct class *cls, dev_t devt);
>
>int __attribute__((__warn_unused_result__)) device_add_groups(struct device *dev,
>       const struct attribute_group **groups);
>void device_remove_groups(struct device *dev,
>     const struct attribute_group **groups);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__)) device_add_group(struct device *dev,
>     const struct attribute_group *grp)
>{
> const struct attribute_group *groups[] = { grp, ((void *)0) };
>
> return device_add_groups(dev, groups);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void device_remove_group(struct device *dev,
>           const struct attribute_group *grp)
>{
> const struct attribute_group *groups[] = { grp, ((void *)0) };
>
> return device_remove_groups(dev, groups);
>}
>
>int __attribute__((__warn_unused_result__)) devm_device_add_groups(struct device *dev,
>     const struct attribute_group **groups);
>void devm_device_remove_groups(struct device *dev,
>          const struct attribute_group **groups);
>int __attribute__((__warn_unused_result__)) devm_device_add_group(struct device *dev,
>           const struct attribute_group *grp);
>void devm_device_remove_group(struct device *dev,
>         const struct attribute_group *grp);
>
>
>
>
>
>
>
>extern int (*platform_notify)(struct device *dev);
>
>extern int (*platform_notify_remove)(struct device *dev);
>
>
>
>
>
>
>struct device *get_device(struct device *dev);
>void put_device(struct device *dev);
>bool kill_device(struct device *dev);
>
>
>int devtmpfs_mount(void);
>
>
>
>
>
>void device_shutdown(void);
>
>
>const char *dev_driver_string(const struct device *dev);
>
>
>struct device_link *device_link_add(struct device *consumer,
>        struct device *supplier, u32 flags);
>void device_link_del(struct device_link *link);
>void device_link_remove(void *consumer, struct device *supplier);
>void device_links_supplier_sync_state_pause(void);
>void device_links_supplier_sync_state_resume(void);
>
>extern __attribute__((__format__(printf, 3, 4)))
>int dev_err_probe(const struct device *dev, int err, const char *fmt, ...);
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_qos.h" 2
>
>enum pm_qos_flags_status {
> PM_QOS_FLAGS_UNDEFINED = -1,
> PM_QOS_FLAGS_NONE,
> PM_QOS_FLAGS_SOME,
> PM_QOS_FLAGS_ALL,
>};
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_qos.h"
>enum pm_qos_type {
> PM_QOS_UNITIALIZED,
> PM_QOS_MAX,
> PM_QOS_MIN,
>};
>
>
>
>
>
>
>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_request {
> struct plist_node node;
> struct pm_qos_constraints *qos;
>};
>
>struct pm_qos_flags_request {
> struct list_head node;
> s32 flags;
>};
>
>struct pm_qos_flags {
> struct list_head list;
> s32 effective_flags;
>};
>
>
>
>
>
>enum freq_qos_req_type {
> FREQ_QOS_MIN = 1,
> FREQ_QOS_MAX,
>};
>
>struct freq_constraints {
> struct pm_qos_constraints min_freq;
> struct blocking_notifier_head min_freq_notifiers;
> struct pm_qos_constraints max_freq;
> struct blocking_notifier_head max_freq_notifiers;
>};
>
>struct freq_qos_request {
> enum freq_qos_req_type type;
> struct plist_node pnode;
> struct freq_constraints *qos;
>};
>
>
>enum dev_pm_qos_req_type {
> DEV_PM_QOS_RESUME_LATENCY = 1,
> DEV_PM_QOS_LATENCY_TOLERANCE,
> DEV_PM_QOS_MIN_FREQUENCY,
> DEV_PM_QOS_MAX_FREQUENCY,
> DEV_PM_QOS_FLAGS,
>};
>
>struct dev_pm_qos_request {
> enum dev_pm_qos_req_type type;
> union {
>  struct plist_node pnode;
>  struct pm_qos_flags_request flr;
>  struct freq_qos_request freq;
> } data;
> struct device *dev;
>};
>
>struct dev_pm_qos {
> struct pm_qos_constraints resume_latency;
> struct pm_qos_constraints latency_tolerance;
> struct freq_constraints freq;
> struct pm_qos_flags flags;
> struct dev_pm_qos_request *resume_latency_req;
> struct dev_pm_qos_request *latency_tolerance_req;
> struct dev_pm_qos_request *flags_req;
>};
>
>
>enum pm_qos_req_action {
> PM_QOS_ADD_REQ,
> PM_QOS_UPDATE_REQ,
> PM_QOS_REMOVE_REQ
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dev_pm_qos_request_active(struct dev_pm_qos_request *req)
>{
> return req->dev != ((void *)0);
>}
>
>s32 pm_qos_read_value(struct pm_qos_constraints *c);
>int pm_qos_update_target(struct pm_qos_constraints *c, struct plist_node *node,
>    enum pm_qos_req_action action, int value);
>bool pm_qos_update_flags(struct pm_qos_flags *pqf,
>    struct pm_qos_flags_request *req,
>    enum pm_qos_req_action action, s32 val);
>
>
>s32 cpu_latency_qos_limit(void);
>bool cpu_latency_qos_request_active(struct pm_qos_request *req);
>void cpu_latency_qos_add_request(struct pm_qos_request *req, s32 value);
>void cpu_latency_qos_update_request(struct pm_qos_request *req, s32 new_value);
>void cpu_latency_qos_remove_request(struct pm_qos_request *req);
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_qos.h"
>enum pm_qos_flags_status __dev_pm_qos_flags(struct device *dev, s32 mask);
>enum pm_qos_flags_status dev_pm_qos_flags(struct device *dev, s32 mask);
>s32 __dev_pm_qos_resume_latency(struct device *dev);
>s32 dev_pm_qos_read_value(struct device *dev, enum dev_pm_qos_req_type type);
>int dev_pm_qos_add_request(struct device *dev, struct dev_pm_qos_request *req,
>      enum dev_pm_qos_req_type type, s32 value);
>int dev_pm_qos_update_request(struct dev_pm_qos_request *req, s32 new_value);
>int dev_pm_qos_remove_request(struct dev_pm_qos_request *req);
>int dev_pm_qos_add_notifier(struct device *dev,
>       struct notifier_block *notifier,
>       enum dev_pm_qos_req_type type);
>int dev_pm_qos_remove_notifier(struct device *dev,
>          struct notifier_block *notifier,
>          enum dev_pm_qos_req_type type);
>void dev_pm_qos_constraints_init(struct device *dev);
>void dev_pm_qos_constraints_destroy(struct device *dev);
>int dev_pm_qos_add_ancestor_request(struct device *dev,
>        struct dev_pm_qos_request *req,
>        enum dev_pm_qos_req_type type, s32 value);
>int dev_pm_qos_expose_latency_limit(struct device *dev, s32 value);
>void dev_pm_qos_hide_latency_limit(struct device *dev);
>int dev_pm_qos_expose_flags(struct device *dev, s32 value);
>void dev_pm_qos_hide_flags(struct device *dev);
>int dev_pm_qos_update_flags(struct device *dev, s32 mask, bool set);
>s32 dev_pm_qos_get_user_latency_tolerance(struct device *dev);
>int dev_pm_qos_update_user_latency_tolerance(struct device *dev, s32 val);
>int dev_pm_qos_expose_latency_tolerance(struct device *dev);
>void dev_pm_qos_hide_latency_tolerance(struct device *dev);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s32 dev_pm_qos_requested_resume_latency(struct device *dev)
>{
> return dev->power.qos->resume_latency_req->data.pnode.prio;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s32 dev_pm_qos_requested_flags(struct device *dev)
>{
> return dev->power.qos->flags_req->data.flr.flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s32 dev_pm_qos_raw_resume_latency(struct device *dev)
>{
> return IS_ERR_OR_NULL(dev->power.qos) ?
>  ((s32)(((u32)~0U) >> 1)) :
>  pm_qos_read_value(&dev->power.qos->resume_latency);
>}
># 294 "/usr/src/linux-5.14.21-150500.53/include/linux/pm_qos.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int freq_qos_request_active(struct freq_qos_request *req)
>{
> return !IS_ERR_OR_NULL(req->qos);
>}
>
>void freq_constraints_init(struct freq_constraints *qos);
>
>s32 freq_qos_read_value(struct freq_constraints *qos,
>   enum freq_qos_req_type type);
>
>int freq_qos_add_request(struct freq_constraints *qos,
>    struct freq_qos_request *req,
>    enum freq_qos_req_type type, s32 value);
>int freq_qos_update_request(struct freq_qos_request *req, s32 new_value);
>int freq_qos_remove_request(struct freq_qos_request *req);
>int freq_qos_apply(struct freq_qos_request *req,
>     enum pm_qos_req_action action, s32 value);
>
>int freq_qos_add_notifier(struct freq_constraints *qos,
>     enum freq_qos_req_type type,
>     struct notifier_block *notifier);
>int freq_qos_remove_notifier(struct freq_constraints *qos,
>        enum freq_qos_req_type type,
>        struct notifier_block *notifier);
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h" 2
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct cpufreq_governor;
>
>enum cpufreq_table_sorting {
> CPUFREQ_TABLE_UNSORTED,
> CPUFREQ_TABLE_SORTED_ASCENDING,
> CPUFREQ_TABLE_SORTED_DESCENDING
>};
>
>struct cpufreq_cpuinfo {
> unsigned int max_freq;
> unsigned int min_freq;
>
>
> unsigned int transition_latency;
>};
>
>struct cpufreq_policy {
>
> cpumask_var_t cpus;
> cpumask_var_t related_cpus;
> cpumask_var_t real_cpus;
>
> unsigned int shared_type;
>
> unsigned int cpu;
>
> struct clk *clk;
> struct cpufreq_cpuinfo cpuinfo;
>
> unsigned int min;
> unsigned int max;
> unsigned int cur;
>
> unsigned int suspend_freq;
>
> unsigned int policy;
> unsigned int last_policy;
> struct cpufreq_governor *governor;
> void *governor_data;
> char last_governor[16];
>
> struct work_struct update;
>
>
> struct freq_constraints constraints;
> struct freq_qos_request *min_freq_req;
> struct freq_qos_request *max_freq_req;
>
> struct cpufreq_frequency_table *freq_table;
> enum cpufreq_table_sorting freq_table_sorted;
>
> struct list_head policy_list;
> struct kobject kobj;
> struct completion kobj_unregister;
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
> struct rw_semaphore rwsem;
># 108 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
> bool fast_switch_possible;
> bool fast_switch_enabled;
>
>
>
>
>
> bool strict_target;
>
>
>
>
>
>
> unsigned int transition_delay_us;
># 131 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
> bool dvfs_possible_from_any_cpu;
>
>
> unsigned int cached_target_freq;
> unsigned int cached_resolved_idx;
>
>
> bool transition_ongoing;
> spinlock_t transition_lock;
> wait_queue_head_t transition_wait;
> struct task_struct *transition_task;
>
>
> struct cpufreq_stats *stats;
>
>
> void *driver_data;
>
>
> struct thermal_cooling_device *cdev;
>
> struct notifier_block nb_min;
> struct notifier_block nb_max;
>};
>
>
>
>
>
>
>
>struct cpufreq_policy_data {
> struct cpufreq_cpuinfo cpuinfo;
> struct cpufreq_frequency_table *freq_table;
> unsigned int cpu;
> unsigned int min;
> unsigned int max;
>};
>
>struct cpufreq_freqs {
> struct cpufreq_policy *policy;
> unsigned int old;
> unsigned int new;
> u8 flags;
>};
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct cpufreq_policy *cpufreq_cpu_get_raw(unsigned int cpu);
>struct cpufreq_policy *cpufreq_cpu_get(unsigned int cpu);
>void cpufreq_cpu_put(struct cpufreq_policy *policy);
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool policy_is_inactive(struct cpufreq_policy *policy)
>{
> return cpumask_empty(policy->cpus);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool policy_is_shared(struct cpufreq_policy *policy)
>{
> return cpumask_weight(policy->cpus) > 1;
>}
>
>
>unsigned int cpufreq_get(unsigned int cpu);
>unsigned int cpufreq_quick_get(unsigned int cpu);
>unsigned int cpufreq_quick_get_max(unsigned int cpu);
>unsigned int cpufreq_get_hw_max_freq(unsigned int cpu);
>void disable_cpufreq(void);
>
>u64 get_cpu_idle_time(unsigned int cpu, u64 *wall, int io_busy);
>
>struct cpufreq_policy *cpufreq_cpu_acquire(unsigned int cpu);
>void cpufreq_cpu_release(struct cpufreq_policy *policy);
>int cpufreq_get_policy(struct cpufreq_policy *policy, unsigned int cpu);
>void refresh_frequency_limits(struct cpufreq_policy *policy);
>void cpufreq_update_policy(unsigned int cpu);
>void cpufreq_update_limits(unsigned int cpu);
>bool have_governor_per_policy(void);
>bool cpufreq_supports_freq_invariance(void);
>struct kobject *get_governor_parent_kobj(struct cpufreq_policy *policy);
>void cpufreq_enable_fast_switch(struct cpufreq_policy *policy);
>void cpufreq_disable_fast_switch(struct cpufreq_policy *policy);
># 259 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpufreq_stats_create_table(struct cpufreq_policy *policy) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpufreq_stats_free_table(struct cpufreq_policy *policy) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpufreq_stats_record_transition(struct cpufreq_policy *policy,
>         unsigned int new_freq) { }
># 273 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct freq_attr {
> struct attribute attr;
> ssize_t (*show)(struct cpufreq_policy *, char *);
> ssize_t (*store)(struct cpufreq_policy *, const char *, size_t count);
>};
># 304 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct cpufreq_driver {
> char name[16];
> u16 flags;
> void *driver_data;
>
>
> int (*init)(struct cpufreq_policy *policy);
> int (*verify)(struct cpufreq_policy_data *policy);
>
>
> int (*setpolicy)(struct cpufreq_policy *policy);
>
> int (*target)(struct cpufreq_policy *policy,
>      unsigned int target_freq,
>      unsigned int relation);
> int (*target_index)(struct cpufreq_policy *policy,
>     unsigned int index);
> unsigned int (*fast_switch)(struct cpufreq_policy *policy,
>           unsigned int target_freq);
>
>
>
>
>
> void (*adjust_perf)(unsigned int cpu,
>           unsigned long min_perf,
>           unsigned long target_perf,
>           unsigned long capacity);
># 348 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
> unsigned int (*get_intermediate)(struct cpufreq_policy *policy,
>         unsigned int index);
> int (*target_intermediate)(struct cpufreq_policy *policy,
>            unsigned int index);
>
>
> unsigned int (*get)(unsigned int cpu);
>
>
> void (*update_limits)(unsigned int cpu);
>
>
> int (*bios_limit)(int cpu, unsigned int *limit);
>
> int (*online)(struct cpufreq_policy *policy);
> int (*offline)(struct cpufreq_policy *policy);
> int (*exit)(struct cpufreq_policy *policy);
> int (*suspend)(struct cpufreq_policy *policy);
> int (*resume)(struct cpufreq_policy *policy);
>
>
> void (*ready)(struct cpufreq_policy *policy);
>
> struct freq_attr **attr;
>
>
> bool boost_enabled;
> int (*set_boost)(struct cpufreq_policy *policy, int state);
>};
># 427 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>int cpufreq_register_driver(struct cpufreq_driver *driver_data);
>int cpufreq_unregister_driver(struct cpufreq_driver *driver_data);
>
>bool cpufreq_driver_test_flags(u16 flags);
>const char *cpufreq_get_current_driver(void);
>void *cpufreq_get_driver_data(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_thermal_control_enabled(struct cpufreq_driver *drv)
>{
> return 0 &&
>  (drv->flags & ((((1UL))) << (2)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpufreq_verify_within_limits(struct cpufreq_policy_data *policy,
>      unsigned int min,
>      unsigned int max)
>{
> if (policy->min < min)
>  policy->min = min;
> if (policy->max < min)
>  policy->max = min;
> if (policy->min > max)
>  policy->min = max;
> if (policy->max > max)
>  policy->max = max;
> if (policy->min > policy->max)
>  policy->min = policy->max;
> return;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>cpufreq_verify_within_cpu_limits(struct cpufreq_policy_data *policy)
>{
> cpufreq_verify_within_limits(policy, policy->cpuinfo.min_freq,
>         policy->cpuinfo.max_freq);
>}
>
>
>void cpufreq_suspend(void);
>void cpufreq_resume(void);
>int cpufreq_generic_suspend(struct cpufreq_policy *policy);
># 489 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>int cpufreq_register_notifier(struct notifier_block *nb, unsigned int list);
>int cpufreq_unregister_notifier(struct notifier_block *nb, unsigned int list);
>
>void cpufreq_freq_transition_begin(struct cpufreq_policy *policy,
>  struct cpufreq_freqs *freqs);
>void cpufreq_freq_transition_end(struct cpufreq_policy *policy,
>  struct cpufreq_freqs *freqs, int transition_failed);
># 520 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long cpufreq_scale(unsigned long old, u_int div,
>  u_int mult)
>{
>
>
>
>
>
>
> unsigned long result = old * ((u64) mult);
> result /= div;
> return result;
>
>}
># 556 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct cpufreq_governor {
> char name[16];
> int (*init)(struct cpufreq_policy *policy);
> void (*exit)(struct cpufreq_policy *policy);
> int (*start)(struct cpufreq_policy *policy);
> void (*stop)(struct cpufreq_policy *policy);
> void (*limits)(struct cpufreq_policy *policy);
> ssize_t (*show_setspeed) (struct cpufreq_policy *policy,
>      char *buf);
> int (*store_setspeed) (struct cpufreq_policy *policy,
>      unsigned int freq);
> struct list_head governor_list;
> struct module *owner;
> u8 flags;
>};
># 582 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>unsigned int cpufreq_driver_fast_switch(struct cpufreq_policy *policy,
>     unsigned int target_freq);
>void cpufreq_driver_adjust_perf(unsigned int cpu,
>    unsigned long min_perf,
>    unsigned long target_perf,
>    unsigned long capacity);
>bool cpufreq_driver_has_adjust_perf(void);
>int cpufreq_driver_target(struct cpufreq_policy *policy,
>     unsigned int target_freq,
>     unsigned int relation);
>int __cpufreq_driver_target(struct cpufreq_policy *policy,
>       unsigned int target_freq,
>       unsigned int relation);
>unsigned int cpufreq_driver_resolve_freq(struct cpufreq_policy *policy,
>      unsigned int target_freq);
>unsigned int cpufreq_policy_transition_delay_us(struct cpufreq_policy *policy);
>int cpufreq_register_governor(struct cpufreq_governor *governor);
>void cpufreq_unregister_governor(struct cpufreq_governor *governor);
>int cpufreq_start_governor(struct cpufreq_policy *policy);
>void cpufreq_stop_governor(struct cpufreq_policy *policy);
># 617 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct cpufreq_governor *cpufreq_default_governor(void);
>struct cpufreq_governor *cpufreq_fallback_governor(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpufreq_policy_apply_limits(struct cpufreq_policy *policy)
>{
> if (policy->max < policy->cur)
>  __cpufreq_driver_target(policy, policy->max, 1);
> else if (policy->min > policy->cur)
>  __cpufreq_driver_target(policy, policy->min, 0);
>}
>
>
>struct gov_attr_set {
> struct kobject kobj;
> struct list_head policy_list;
> struct mutex update_lock;
> int usage_count;
>};
>
>
>extern const struct sysfs_ops governor_sysfs_ops;
>
>void gov_attr_set_init(struct gov_attr_set *attr_set, struct list_head *list_node);
>void gov_attr_set_get(struct gov_attr_set *attr_set, struct list_head *list_node);
>unsigned int gov_attr_set_put(struct gov_attr_set *attr_set, struct list_head *list_node);
>
>
>struct governor_attr {
> struct attribute attr;
> ssize_t (*show)(struct gov_attr_set *attr_set, char *buf);
> ssize_t (*store)(struct gov_attr_set *attr_set, const char *buf,
>    size_t count);
>};
># 661 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>struct cpufreq_frequency_table {
> unsigned int flags;
> unsigned int driver_data;
> unsigned int frequency;
>
>};
>
>
>int dev_pm_opp_init_cpufreq_table(struct device *dev,
>      struct cpufreq_frequency_table **table);
>void dev_pm_opp_free_cpufreq_table(struct device *dev,
>       struct cpufreq_frequency_table **table);
># 737 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>int cpufreq_frequency_table_cpuinfo(struct cpufreq_policy *policy,
>        struct cpufreq_frequency_table *table);
>
>int cpufreq_frequency_table_verify(struct cpufreq_policy_data *policy,
>       struct cpufreq_frequency_table *table);
>int cpufreq_generic_frequency_table_verify(struct cpufreq_policy_data *policy);
>
>int cpufreq_table_index_unsorted(struct cpufreq_policy *policy,
>     unsigned int target_freq,
>     unsigned int relation);
>int cpufreq_frequency_table_get_index(struct cpufreq_policy *policy,
>  unsigned int freq);
>
>ssize_t cpufreq_show_cpus(const struct cpumask *mask, char *buf);
>
>
>int cpufreq_boost_trigger_state(int state);
>int cpufreq_boost_enabled(void);
>int cpufreq_enable_boost_support(void);
>bool policy_has_boost_freq(struct cpufreq_policy *policy);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_al(struct cpufreq_policy *policy,
>           unsigned int target_freq)
>{
> struct cpufreq_frequency_table *table = policy->freq_table;
> struct cpufreq_frequency_table *pos;
> unsigned int freq;
> int idx, best = -1;
>
> for (pos = table, idx = 0; pos->frequency != ~1u; pos++, idx++) if (pos->frequency == ~0u) continue; else {
>  freq = pos->frequency;
>
>  if (freq >= target_freq)
>   return idx;
>
>  best = idx;
> }
>
> return best;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_dl(struct cpufreq_policy *policy,
>           unsigned int target_freq)
>{
> struct cpufreq_frequency_table *table = policy->freq_table;
> struct cpufreq_frequency_table *pos;
> unsigned int freq;
> int idx, best = -1;
>
> for (pos = table, idx = 0; pos->frequency != ~1u; pos++, idx++) if (pos->frequency == ~0u) continue; else {
>  freq = pos->frequency;
>
>  if (freq == target_freq)
>   return idx;
>
>  if (freq > target_freq) {
>   best = idx;
>   continue;
>  }
>
>
>  if (best == -1)
>   return idx;
>
>  return best;
> }
>
> return best;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_l(struct cpufreq_policy *policy,
>          unsigned int target_freq)
>{
> target_freq = __builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x266 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y267 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x266) > (__UNIQUE_ID___y267) ? (__UNIQUE_ID___x266) : (__UNIQUE_ID___y267)); })))) *)1 == (typeof((typeof(target_freq))(policy->max)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x266 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y267 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x266) > (__UNIQUE_ID___y267) ? (__UNIQUE_ID___x266) : (__UNIQUE_ID___y267)); })))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->max)) * 0l)) : (int *)8))))), (((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x266 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y267 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x266) > (__UNIQUE_ID___y267) ? (__UNIQUE_ID___x266) : (__UNIQUE_ID___y267)); })))) < ((typeof(target_freq))(policy->max)) ? ((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x266 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y267 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x266) > (__UNIQUE_ID___y267) ? (__UNIQUE_ID___x266) : (__UNIQUE_ID___y267)); })))) : ((typeof(target_freq))(policy->max))), ({ typeof((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x266 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y267 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x266) > (__UNIQUE_ID___y267) ? (__UNIQUE_ID___x266) : (__UNIQUE_ID___y267)); })))) __UNIQUE_ID___x268 = ((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x266 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y267 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x266) > (__UNIQUE_ID___y267) ? (__UNIQUE_ID___x266) : (__UNIQUE_ID___y267)); })))); typeof((typeof(target_freq))(policy->max)) __UNIQUE_ID___y269 = ((typeof(target_freq))(policy->max)); ((__UNIQUE_ID___x268) < (__UNIQUE_ID___y269) ? (__UNIQUE_ID___x268) : (__UNIQUE_ID___y269)); }));
>
> if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
>  return cpufreq_table_find_index_al(policy, target_freq);
> else
>  return cpufreq_table_find_index_dl(policy, target_freq);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_ah(struct cpufreq_policy *policy,
>           unsigned int target_freq)
>{
> struct cpufreq_frequency_table *table = policy->freq_table;
> struct cpufreq_frequency_table *pos;
> unsigned int freq;
> int idx, best = -1;
>
> for (pos = table, idx = 0; pos->frequency != ~1u; pos++, idx++) if (pos->frequency == ~0u) continue; else {
>  freq = pos->frequency;
>
>  if (freq == target_freq)
>   return idx;
>
>  if (freq < target_freq) {
>   best = idx;
>   continue;
>  }
>
>
>  if (best == -1)
>   return idx;
>
>  return best;
> }
>
> return best;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_dh(struct cpufreq_policy *policy,
>           unsigned int target_freq)
>{
> struct cpufreq_frequency_table *table = policy->freq_table;
> struct cpufreq_frequency_table *pos;
> unsigned int freq;
> int idx, best = -1;
>
> for (pos = table, idx = 0; pos->frequency != ~1u; pos++, idx++) if (pos->frequency == ~0u) continue; else {
>  freq = pos->frequency;
>
>  if (freq <= target_freq)
>   return idx;
>
>  best = idx;
> }
>
> return best;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_h(struct cpufreq_policy *policy,
>          unsigned int target_freq)
>{
> target_freq = __builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x270 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y271 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x270) > (__UNIQUE_ID___y271) ? (__UNIQUE_ID___x270) : (__UNIQUE_ID___y271)); })))) *)1 == (typeof((typeof(target_freq))(policy->max)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x270 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y271 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x270) > (__UNIQUE_ID___y271) ? (__UNIQUE_ID___x270) : (__UNIQUE_ID___y271)); })))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->max)) * 0l)) : (int *)8))))), (((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x270 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y271 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x270) > (__UNIQUE_ID___y271) ? (__UNIQUE_ID___x270) : (__UNIQUE_ID___y271)); })))) < ((typeof(target_freq))(policy->max)) ? ((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x270 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y271 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x270) > (__UNIQUE_ID___y271) ? (__UNIQUE_ID___x270) : (__UNIQUE_ID___y271)); })))) : ((typeof(target_freq))(policy->max))), ({ typeof((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x270 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y271 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x270) > (__UNIQUE_ID___y271) ? (__UNIQUE_ID___x270) : (__UNIQUE_ID___y271)); })))) __UNIQUE_ID___x272 = ((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x270 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y271 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x270) > (__UNIQUE_ID___y271) ? (__UNIQUE_ID___x270) : (__UNIQUE_ID___y271)); })))); typeof((typeof(target_freq))(policy->max)) __UNIQUE_ID___y273 = ((typeof(target_freq))(policy->max)); ((__UNIQUE_ID___x272) < (__UNIQUE_ID___y273) ? (__UNIQUE_ID___x272) : (__UNIQUE_ID___y273)); }));
>
> if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
>  return cpufreq_table_find_index_ah(policy, target_freq);
> else
>  return cpufreq_table_find_index_dh(policy, target_freq);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_ac(struct cpufreq_policy *policy,
>           unsigned int target_freq)
>{
> struct cpufreq_frequency_table *table = policy->freq_table;
> struct cpufreq_frequency_table *pos;
> unsigned int freq;
> int idx, best = -1;
>
> for (pos = table, idx = 0; pos->frequency != ~1u; pos++, idx++) if (pos->frequency == ~0u) continue; else {
>  freq = pos->frequency;
>
>  if (freq == target_freq)
>   return idx;
>
>  if (freq < target_freq) {
>   best = idx;
>   continue;
>  }
>
>
>  if (best == -1)
>   return idx;
>
>
>  if (target_freq - table[best].frequency > freq - target_freq)
>   return idx;
>
>  return best;
> }
>
> return best;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_dc(struct cpufreq_policy *policy,
>           unsigned int target_freq)
>{
> struct cpufreq_frequency_table *table = policy->freq_table;
> struct cpufreq_frequency_table *pos;
> unsigned int freq;
> int idx, best = -1;
>
> for (pos = table, idx = 0; pos->frequency != ~1u; pos++, idx++) if (pos->frequency == ~0u) continue; else {
>  freq = pos->frequency;
>
>  if (freq == target_freq)
>   return idx;
>
>  if (freq > target_freq) {
>   best = idx;
>   continue;
>  }
>
>
>  if (best == -1)
>   return idx;
>
>
>  if (table[best].frequency - target_freq > target_freq - freq)
>   return idx;
>
>  return best;
> }
>
> return best;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_find_index_c(struct cpufreq_policy *policy,
>          unsigned int target_freq)
>{
> target_freq = __builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x274 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y275 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x274) > (__UNIQUE_ID___y275) ? (__UNIQUE_ID___x274) : (__UNIQUE_ID___y275)); })))) *)1 == (typeof((typeof(target_freq))(policy->max)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x274 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y275 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x274) > (__UNIQUE_ID___y275) ? (__UNIQUE_ID___x274) : (__UNIQUE_ID___y275)); })))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->max)) * 0l)) : (int *)8))))), (((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x274 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y275 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x274) > (__UNIQUE_ID___y275) ? (__UNIQUE_ID___x274) : (__UNIQUE_ID___y275)); })))) < ((typeof(target_freq))(policy->max)) ? ((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x274 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y275 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x274) > (__UNIQUE_ID___y275) ? (__UNIQUE_ID___x274) : (__UNIQUE_ID___y275)); })))) : ((typeof(target_freq))(policy->max))), ({ typeof((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x274 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y275 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x274) > (__UNIQUE_ID___y275) ? (__UNIQUE_ID___x274) : (__UNIQUE_ID___y275)); })))) __UNIQUE_ID___x276 = ((typeof(target_freq))(__builtin_choose_expr(((!!(sizeof((typeof((typeof(target_freq))(target_freq)) *)1 == (typeof((typeof(target_freq))(policy->min)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(target_freq)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((typeof(target_freq))(policy->min)) * 0l)) : (int *)8))))), (((typeof(target_freq))(target_freq)) > ((typeof(target_freq))(policy->min)) ? ((typeof(target_freq))(target_freq)) : ((typeof(target_freq))(policy->min))), ({ typeof((typeof(target_freq))(target_freq)) __UNIQUE_ID___x274 = ((typeof(target_freq))(target_freq)); typeof((typeof(target_freq))(policy->min)) __UNIQUE_ID___y275 = ((typeof(target_freq))(policy->min)); ((__UNIQUE_ID___x274) > (__UNIQUE_ID___y275) ? (__UNIQUE_ID___x274) : (__UNIQUE_ID___y275)); })))); typeof((typeof(target_freq))(policy->max)) __UNIQUE_ID___y277 = ((typeof(target_freq))(policy->max)); ((__UNIQUE_ID___x276) < (__UNIQUE_ID___y277) ? (__UNIQUE_ID___x276) : (__UNIQUE_ID___y277)); }));
>
> if (policy->freq_table_sorted == CPUFREQ_TABLE_SORTED_ASCENDING)
>  return cpufreq_table_find_index_ac(policy, target_freq);
> else
>  return cpufreq_table_find_index_dc(policy, target_freq);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_frequency_table_target(struct cpufreq_policy *policy,
>       unsigned int target_freq,
>       unsigned int relation)
>{
> if (__builtin_expect(!!(policy->freq_table_sorted == CPUFREQ_TABLE_UNSORTED), 0))
>  return cpufreq_table_index_unsorted(policy, target_freq,
>          relation);
>
> switch (relation) {
> case 0:
>  return cpufreq_table_find_index_l(policy, target_freq);
> case 1:
>  return cpufreq_table_find_index_h(policy, target_freq);
> case 2:
>  return cpufreq_table_find_index_c(policy, target_freq);
> default:
>  ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"), "i" (980), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("278" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "278" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>  return 0;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpufreq_table_count_valid_entries(const struct cpufreq_policy *policy)
>{
> struct cpufreq_frequency_table *pos;
> int count = 0;
>
> if (__builtin_expect(!!(!policy->freq_table), 0))
>  return 0;
>
> for (pos = policy->freq_table; pos->frequency != ~1u; pos++) if (pos->frequency == ~0u) continue; else
>  count++;
>
> return count;
>}
># 1020 "/usr/src/linux-5.14.21-150500.53/include/linux/cpufreq.h"
>void sched_cpufreq_governor_change(struct cpufreq_policy *policy,
>   struct cpufreq_governor *old_gov);
>
>
>
>
>
>extern void arch_freq_prepare_all(void);
>extern unsigned int arch_freq_get_on_cpu(int cpu);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void arch_set_freq_scale(const struct cpumask *cpus,
>    unsigned long cur_freq,
>    unsigned long max_freq)
>{
>}
>
>
>
>extern struct freq_attr cpufreq_freq_attr_scaling_available_freqs;
>extern struct freq_attr cpufreq_freq_attr_scaling_boost_freqs;
>extern struct freq_attr *cpufreq_generic_attr[];
>int cpufreq_table_validate_and_sort(struct cpufreq_policy *policy);
>
>unsigned int cpufreq_generic_get(unsigned int cpu);
>void cpufreq_generic_init(struct cpufreq_policy *policy,
>  struct cpufreq_frequency_table *table,
>  unsigned int transition_latency);
># 92 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h" 1
># 138 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>struct mem_cgroup;
>
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) kmem_cache_init(void);
>bool slab_is_available(void);
>
>extern bool usercopy_fallback;
>
>struct kmem_cache *kmem_cache_create(const char *name, unsigned int size,
>   unsigned int align, slab_flags_t flags,
>   void (*ctor)(void *));
>struct kmem_cache *kmem_cache_create_usercopy(const char *name,
>   unsigned int size, unsigned int align,
>   slab_flags_t flags,
>   unsigned int useroffset, unsigned int usersize,
>   void (*ctor)(void *));
>void kmem_cache_destroy(struct kmem_cache *);
>int kmem_cache_shrink(struct kmem_cache *);
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>void * __attribute__((__warn_unused_result__)) krealloc(const void *, size_t, gfp_t);
>void kfree(const void *);
>void kfree_sensitive(const void *);
>size_t __ksize(const void *);
>size_t ksize(const void *);
>
>bool kmem_valid_obj(void *object);
>void kmem_dump_obj(void *object);
>
>
>
>void __check_heap_object(const void *ptr, unsigned long n, struct page *page,
>   bool to_user);
># 313 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>enum kmalloc_cache_type {
> KMALLOC_NORMAL = 0,
>
>
>
>
>
>
> KMALLOC_CGROUP,
>
> KMALLOC_RECLAIM,
>
> KMALLOC_DMA,
>
> NR_KMALLOC_TYPES
>};
>
>
>extern struct kmem_cache *
>kmalloc_caches[NR_KMALLOC_TYPES][(12 + 1) + 1];
># 342 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) enum kmalloc_cache_type kmalloc_type(gfp_t flags)
>{
>
>
>
>
> if (__builtin_expect(!!((flags & ((( gfp_t)0x10u) | (1 ? (( gfp_t)0x01u) : 0) | (1 ? (( gfp_t)0x400000u) : 0))) == 0), 1))
>  return KMALLOC_NORMAL;
># 358 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
> if (1 && (flags & (( gfp_t)0x01u)))
>  return KMALLOC_DMA;
> if (!1 || (flags & (( gfp_t)0x10u)))
>  return KMALLOC_RECLAIM;
> else
>  return KMALLOC_CGROUP;
>}
># 379 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) unsigned int __kmalloc_index(size_t size,
>          bool size_is_constant)
>{
> if (!size)
>  return 0;
>
> if (size <= (1 << 3))
>  return 3;
>
> if ((1 << 3) <= 32 && size > 64 && size <= 96)
>  return 1;
> if ((1 << 3) <= 64 && size > 128 && size <= 192)
>  return 2;
> if (size <= 8) return 3;
> if (size <= 16) return 4;
> if (size <= 32) return 5;
> if (size <= 64) return 6;
> if (size <= 128) return 7;
> if (size <= 256) return 8;
> if (size <= 512) return 9;
> if (size <= 1024) return 10;
> if (size <= 2 * 1024) return 11;
> if (size <= 4 * 1024) return 12;
> if (size <= 8 * 1024) return 13;
> if (size <= 16 * 1024) return 14;
> if (size <= 32 * 1024) return 15;
> if (size <= 64 * 1024) return 16;
> if (size <= 128 * 1024) return 17;
> if (size <= 256 * 1024) return 18;
> if (size <= 512 * 1024) return 19;
> if (size <= 1024 * 1024) return 20;
> if (size <= 2 * 1024 * 1024) return 21;
> if (size <= 4 * 1024 * 1024) return 22;
> if (size <= 8 * 1024 * 1024) return 23;
> if (size <= 16 * 1024 * 1024) return 24;
> if (size <= 32 * 1024 * 1024) return 25;
>
> if ((1 || 0 >= 110000)
>     && !0 && size_is_constant)
>  do { extern void __compiletime_assert_279(void) __attribute__((__error__("unexpected size in kmalloc_index()"))); if (!(!(1))) __compiletime_assert_279(); } while (0);
> else
>  do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"), "i" (420), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("280" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "280" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0);
>
>
> return -1;
>}
>
>
>
>void *__kmalloc(size_t size, gfp_t flags) __attribute__((__assume_aligned__(__alignof__(unsigned long long)))) __attribute__((__malloc__));
>void *kmem_cache_alloc(struct kmem_cache *, gfp_t flags) __attribute__((__assume_aligned__(__alignof__(unsigned long long)))) __attribute__((__malloc__));
>void kmem_cache_free(struct kmem_cache *, void *);
># 439 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>void kmem_cache_free_bulk(struct kmem_cache *, size_t, void **);
>int kmem_cache_alloc_bulk(struct kmem_cache *, gfp_t, size_t, void **);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void kfree_bulk(size_t size, void **p)
>{
> kmem_cache_free_bulk(((void *)0), size, p);
>}
>
>
>void *__kmalloc_node(size_t size, gfp_t flags, int node) __attribute__((__assume_aligned__(__alignof__(unsigned long long)))) __attribute__((__malloc__));
>void *kmem_cache_alloc_node(struct kmem_cache *, gfp_t flags, int node) __attribute__((__assume_aligned__(__alignof__(unsigned long long)))) __attribute__((__malloc__));
># 467 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>extern void *kmem_cache_alloc_trace(struct kmem_cache *, gfp_t, size_t) __attribute__((__assume_aligned__(__alignof__(unsigned long long)))) __attribute__((__malloc__));
>
>
>extern void *kmem_cache_alloc_node_trace(struct kmem_cache *s,
>        gfp_t gfpflags,
>        int node, size_t size) __attribute__((__assume_aligned__(__alignof__(unsigned long long)))) __attribute__((__malloc__));
># 505 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>extern void *kmalloc_order(size_t size, gfp_t flags, unsigned int order) __attribute__((__assume_aligned__(((1UL) << 12)))) __attribute__((__malloc__));
>
>
>extern void *kmalloc_order_trace(size_t size, gfp_t flags, unsigned int order) __attribute__((__assume_aligned__(((1UL) << 12)))) __attribute__((__malloc__));
># 517 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void *kmalloc_large(size_t size, gfp_t flags)
>{
> unsigned int order = get_order(size);
> return kmalloc_order_trace(size, flags, order);
>}
># 577 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void *kmalloc(size_t size, gfp_t flags)
>{
> if (__builtin_constant_p(size)) {
>
>  unsigned int index;
>
>  if (size > (1UL << (12 + 1)))
>   return kmalloc_large(size, flags);
>
>  index = __kmalloc_index(size, true);
>
>  if (!index)
>   return ((void *)16);
>
>  return kmem_cache_alloc_trace(
>    kmalloc_caches[kmalloc_type(flags)][index],
>    flags, size);
>
> }
> return __kmalloc(size, flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void *kmalloc_node(size_t size, gfp_t flags, int node)
>{
>
> if (__builtin_constant_p(size) &&
>  size <= (1UL << (12 + 1))) {
>  unsigned int i = __kmalloc_index(size, true);
>
>  if (!i)
>   return ((void *)16);
>
>  return kmem_cache_alloc_node_trace(
>    kmalloc_caches[kmalloc_type(flags)][i],
>      flags, node, size);
> }
>
> return __kmalloc_node(size, flags, node);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmalloc_array(size_t n, size_t size, gfp_t flags)
>{
> size_t bytes;
>
> if (__builtin_expect(!!(__must_check_overflow(({ typeof(n) __a = (n); typeof(size) __b = (size); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_mul_overflow(__a, __b, __d); }))), 0))
>  return ((void *)0);
> if (__builtin_constant_p(n) && __builtin_constant_p(size))
>  return kmalloc(bytes, flags);
> return __kmalloc(bytes, flags);
>}
># 641 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>static __attribute__((__warn_unused_result__)) inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *
>krealloc_array(void *p, size_t new_n, size_t new_size, gfp_t flags)
>{
> size_t bytes;
>
> if (__builtin_expect(!!(__must_check_overflow(({ typeof(new_n) __a = (new_n); typeof(new_size) __b = (new_size); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_mul_overflow(__a, __b, __d); }))), 0))
>  return ((void *)0);
>
> return krealloc(p, bytes, flags);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kcalloc(size_t n, size_t size, gfp_t flags)
>{
> return kmalloc_array(n, size, flags | (( gfp_t)0x100u));
>}
># 671 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>extern void *__kmalloc_track_caller(size_t, gfp_t, unsigned long);
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmalloc_array_node(size_t n, size_t size, gfp_t flags,
>           int node)
>{
> size_t bytes;
>
> if (__builtin_expect(!!(__must_check_overflow(({ typeof(n) __a = (n); typeof(size) __b = (size); typeof(&bytes) __d = (&bytes); (void) (&__a == &__b); (void) (&__a == __d); __builtin_mul_overflow(__a, __b, __d); }))), 0))
>  return ((void *)0);
> if (__builtin_constant_p(n) && __builtin_constant_p(size))
>  return kmalloc_node(bytes, flags, node);
> return __kmalloc_node(bytes, flags, node);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kcalloc_node(size_t n, size_t size, gfp_t flags, int node)
>{
> return kmalloc_array_node(n, size, flags | (( gfp_t)0x100u), node);
>}
>
>
>
>extern void *__kmalloc_node_track_caller(size_t, gfp_t, int, unsigned long);
># 709 "/usr/src/linux-5.14.21-150500.53/include/linux/slab.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
>{
> return kmem_cache_alloc(k, flags | (( gfp_t)0x100u));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kzalloc(size_t size, gfp_t flags)
>{
> return kmalloc(size, flags | (( gfp_t)0x100u));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kzalloc_node(size_t size, gfp_t flags, int node)
>{
> return kmalloc_node(size, flags | (( gfp_t)0x100u), node);
>}
>
>unsigned int kmem_cache_size(struct kmem_cache *s);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) kmem_cache_init_late(void);
># 94 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vmalloc.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pgtable_areas.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vmalloc.h" 2
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_vmap_pud_supported(pgprot_t prot)
>{
> return (__builtin_constant_p(( 1*32+26)) && ( (((( 1*32+26))>>5)==(0) && (1UL<<((( 1*32+26))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 1*32+26))>>5)==(1) && (1UL<<((( 1*32+26))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 1*32+26))>>5)==(2) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(3) && (1UL<<((( 1*32+26))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 1*32+26))>>5)==(4) && (1UL<<((( 1*32+26))&31) & (0) )) || (((( 1*32+26))>>5)==(5) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(6) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(7) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(8) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(9) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(10) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(11) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(12) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(13) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(14) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(15) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(16) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(17) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(18) && (1UL<<((( 1*32+26))&31) & 0 )) || (((( 1*32+26))>>5)==(19) && (1UL<<((( 1*32+26))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 1*32+26), (unsigned long *)((&boot_cpu_data)->x86_capability)));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_vmap_pmd_supported(pgprot_t prot)
>{
> return (__builtin_constant_p(( 0*32+ 3)) && ( (((( 0*32+ 3))>>5)==(0) && (1UL<<((( 0*32+ 3))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 0*32+ 3))>>5)==(1) && (1UL<<((( 0*32+ 3))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 0*32+ 3))>>5)==(2) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(3) && (1UL<<((( 0*32+ 3))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 0*32+ 3))>>5)==(4) && (1UL<<((( 0*32+ 3))&31) & (0) )) || (((( 0*32+ 3))>>5)==(5) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(6) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(7) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(8) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(9) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(10) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(11) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(12) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(13) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(14) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(15) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(16) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(17) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(18) && (1UL<<((( 0*32+ 3))&31) & 0 )) || (((( 0*32+ 3))>>5)==(19) && (1UL<<((( 0*32+ 3))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 0*32+ 3), (unsigned long *)((&boot_cpu_data)->x86_capability)));
>}
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h" 2
>
>struct vm_area_struct;
>struct notifier_block;
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
>struct vm_struct {
> struct vm_struct *next;
> void *addr;
> unsigned long size;
> unsigned long flags;
> struct page **pages;
>
> unsigned int page_order;
>
> unsigned int nr_pages;
> phys_addr_t phys_addr;
> const void *caller;
>};
>
>struct vmap_area {
> unsigned long va_start;
> unsigned long va_end;
>
> struct rb_node rb_node;
> struct list_head list;
>
>
>
>
>
>
>
> union {
>  unsigned long subtree_max_size;
>  struct vm_struct *vm;
> };
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_vmap_p4d_supported(pgprot_t prot)
>{
> return false;
>}
># 108 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long arch_vmap_pte_range_map_size(unsigned long addr, unsigned long end,
>        u64 pfn, unsigned int max_page_shift)
>{
> return ((1UL) << 12);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_vmap_pte_supported_shift(unsigned long size)
>{
> return 12;
>}
>
>
>
>
>
>extern void vm_unmap_ram(const void *mem, unsigned int count);
>extern void *vm_map_ram(struct page **pages, unsigned int count, int node);
>extern void vm_unmap_aliases(void);
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) vmalloc_init(void);
>extern unsigned long vmalloc_nr_pages(void);
>
>
>
>
>
>
>
>extern void *vmalloc(unsigned long size);
>extern void *vzalloc(unsigned long size);
>extern void *vmalloc_user(unsigned long size);
>extern void *vmalloc_node(unsigned long size, int node);
>extern void *vzalloc_node(unsigned long size, int node);
>extern void *vmalloc_32(unsigned long size);
>extern void *vmalloc_32_user(unsigned long size);
>extern void *__vmalloc(unsigned long size, gfp_t gfp_mask);
>extern void *__vmalloc_node_range(unsigned long size, unsigned long align,
>   unsigned long start, unsigned long end, gfp_t gfp_mask,
>   pgprot_t prot, unsigned long vm_flags, int node,
>   const void *caller);
>void *__vmalloc_node(unsigned long size, unsigned long align, gfp_t gfp_mask,
>  int node, const void *caller);
>void *vmalloc_no_huge(unsigned long size);
>
>extern void *__vmalloc_array(size_t n, size_t size, gfp_t flags);
>extern void *vmalloc_array(size_t n, size_t size);
>extern void *__vcalloc(size_t n, size_t size, gfp_t flags);
>extern void *vcalloc(size_t n, size_t size);
>
>extern void vfree(const void *addr);
>extern void vfree_atomic(const void *addr);
>
>extern void *vmap(struct page **pages, unsigned int count,
>   unsigned long flags, pgprot_t prot);
>void *vmap_pfn(unsigned long *pfns, unsigned int count, pgprot_t prot);
>extern void vunmap(const void *addr);
>
>extern int remap_vmalloc_range_partial(struct vm_area_struct *vma,
>           unsigned long uaddr, void *kaddr,
>           unsigned long pgoff, unsigned long size);
>
>extern int remap_vmalloc_range(struct vm_area_struct *vma, void *addr,
>       unsigned long pgoff);
># 189 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
>void arch_sync_kernel_mappings(unsigned long start, unsigned long end);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t get_vm_area_size(const struct vm_struct *area)
>{
> if (!(area->flags & 0x00000040))
>
>  return area->size - ((1UL) << 12);
> else
>  return area->size;
>
>}
>
>extern struct vm_struct *get_vm_area(unsigned long size, unsigned long flags);
>extern struct vm_struct *get_vm_area_caller(unsigned long size,
>     unsigned long flags, const void *caller);
>extern struct vm_struct *__get_vm_area_caller(unsigned long size,
>     unsigned long flags,
>     unsigned long start, unsigned long end,
>     const void *caller);
>void free_vm_area(struct vm_struct *area);
>extern struct vm_struct *remove_vm_area(const void *addr);
>extern struct vm_struct *find_vm_area(const void *addr);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_vm_area_hugepages(const void *addr)
>{
># 226 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
> return find_vm_area(addr)->page_order > 0;
>
>
>
>}
>
>
>int vmap_range(unsigned long addr, unsigned long end,
>   phys_addr_t phys_addr, pgprot_t prot,
>   unsigned int max_page_shift);
>void vunmap_range(unsigned long addr, unsigned long end);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_vm_flush_reset_perms(void *addr)
>{
> struct vm_struct *vm = find_vm_area(addr);
>
> if (vm)
>  vm->flags |= 0x00000100;
>}
># 252 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
>extern long vread(char *buf, char *addr, unsigned long count);
>
>
>
>
>extern struct list_head vmap_area_list;
>extern __attribute__((__section__(".init.text"))) __attribute__((__cold__)) void vm_area_add_early(struct vm_struct *vm);
>extern __attribute__((__section__(".init.text"))) __attribute__((__cold__)) void vm_area_register_early(struct vm_struct *vm, size_t align);
>
>
>
>struct vm_struct **pcpu_get_vm_areas(const unsigned long *offsets,
>         const size_t *sizes, int nr_vms,
>         size_t align);
>
>void pcpu_free_vm_areas(struct vm_struct **vms, int nr_vms);
># 290 "/usr/src/linux-5.14.21-150500.53/include/linux/vmalloc.h"
>int register_vmap_purge_notifier(struct notifier_block *nb);
>int unregister_vmap_purge_notifier(struct notifier_block *nb);
>
>
>bool vmalloc_dump_obj(void *object);
># 95 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/poll.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/poll.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/poll.h" 1
># 1 "./arch/x86/include/generated/uapi/asm/poll.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/poll.h" 1
># 36 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/poll.h"
>struct pollfd {
> int fd;
> short events;
> short revents;
>};
># 1 "./arch/x86/include/generated/uapi/asm/poll.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/poll.h" 2
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/poll.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/eventpoll.h" 1
># 83 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/eventpoll.h"
>struct epoll_event {
> __poll_t events;
> __u64 data;
>} __attribute__((packed));
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ep_take_care_of_epollwakeup(struct epoll_event *epev)
>{
> if ((epev->events & (( __poll_t)(1U << 29))) && !capable(36))
>  epev->events &= ~(( __poll_t)(1U << 29));
>}
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/poll.h" 2
>
>extern struct ctl_table epoll_table[];
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/poll.h"
>struct poll_table_struct;
>
>
>
>
>typedef void (*poll_queue_proc)(struct file *, wait_queue_head_t *, struct poll_table_struct *);
>
>
>
>
>
>typedef struct poll_table_struct {
> poll_queue_proc _qproc;
> __poll_t _key;
>} poll_table;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void poll_wait(struct file * filp, wait_queue_head_t * wait_address, poll_table *p)
>{
> if (p && p->_qproc && wait_address)
>  p->_qproc(filp, wait_address, p);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool poll_does_not_wait(const poll_table *p)
>{
> return p == ((void *)0) || p->_qproc == ((void *)0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __poll_t poll_requested_events(const poll_table *p)
>{
> return p ? p->_key : ~(__poll_t)0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void init_poll_funcptr(poll_table *pt, poll_queue_proc qproc)
>{
> pt->_qproc = qproc;
> pt->_key = ~(__poll_t)0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool file_can_poll(struct file *file)
>{
> return file->f_op->poll;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __poll_t vfs_poll(struct file *file, struct poll_table_struct *pt)
>{
> if (__builtin_expect(!!(!file->f_op->poll), 0))
>  return (( __poll_t)0x00000001 | ( __poll_t)0x00000004 | ( __poll_t)0x00000040 | ( __poll_t)0x00000100);
> return file->f_op->poll(file, pt);
>}
>
>struct poll_table_entry {
> struct file *filp;
> __poll_t key;
> wait_queue_entry_t wait;
> wait_queue_head_t *wait_address;
>};
>
>
>
>
>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[((832 - 256) / sizeof(struct poll_table_entry))];
>};
>
>extern void poll_initwait(struct poll_wqueues *pwq);
>extern void poll_freewait(struct poll_wqueues *pwq);
>extern u64 select_estimate_accuracy(struct timespec64 *tv);
>
>
>
>extern int core_sys_select(int n, fd_set *inp, fd_set *outp,
>      fd_set *exp, struct timespec64 *end_time);
>
>extern int poll_select_set_timeout(struct timespec64 *to, time64_t sec,
>       long nsec);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __u16 mangle_poll(__poll_t val)
>{
> __u16 v = ( __u16)val;
>
> return (( __u16)( __poll_t)0x00000001 < 0x0001 ? (v & ( __u16)( __poll_t)0x00000001) * (0x0001/( __u16)( __poll_t)0x00000001) : (v & ( __u16)( __poll_t)0x00000001) / (( __u16)( __poll_t)0x00000001/0x0001)) | (( __u16)( __poll_t)0x00000004 < 0x0004 ? (v & ( __u16)( __poll_t)0x00000004) * (0x0004/( __u16)( __poll_t)0x00000004) : (v & ( __u16)( __poll_t)0x00000004) / (( __u16)( __poll_t)0x00000004/0x0004)) | (( __u16)( __poll_t)0x00000002 < 0x0002 ? (v & ( __u16)( __poll_t)0x00000002) * (0x0002/( __u16)( __poll_t)0x00000002) : (v & ( __u16)( __poll_t)0x00000002) / (( __u16)( __poll_t)0x00000002/0x0002)) | (( __u16)( __poll_t)0x00000008 < 0x0008 ? (v & ( __u16)( __poll_t)0x00000008) * (0x0008/( __u16)( __poll_t)0x00000008) : (v & ( __u16)( __poll_t)0x00000008) / (( __u16)( __poll_t)0x00000008/0x0008)) | (( __u16)( __poll_t)0x00000020 < 0x0020 ? (v & ( __u16)( __poll_t)0x00000020) * (0x0020/( __u16)( __poll_t)0x00000020) : (v & ( __u16)( __poll_t)0x00000020) / (( __u16)( __poll_t)0x00000020/0x0020)) |
>  (( __u16)( __poll_t)0x00000040 < 0x0040 ? (v & ( __u16)( __poll_t)0x00000040) * (0x0040/( __u16)( __poll_t)0x00000040) : (v & ( __u16)( __poll_t)0x00000040) / (( __u16)( __poll_t)0x00000040/0x0040)) | (( __u16)( __poll_t)0x00000080 < 0x0080 ? (v & ( __u16)( __poll_t)0x00000080) * (0x0080/( __u16)( __poll_t)0x00000080) : (v & ( __u16)( __poll_t)0x00000080) / (( __u16)( __poll_t)0x00000080/0x0080)) | (( __u16)( __poll_t)0x00000100 < 0x0100 ? (v & ( __u16)( __poll_t)0x00000100) * (0x0100/( __u16)( __poll_t)0x00000100) : (v & ( __u16)( __poll_t)0x00000100) / (( __u16)( __poll_t)0x00000100/0x0100)) | (( __u16)( __poll_t)0x00000200 < 0x0200 ? (v & ( __u16)( __poll_t)0x00000200) * (0x0200/( __u16)( __poll_t)0x00000200) : (v & ( __u16)( __poll_t)0x00000200) / (( __u16)( __poll_t)0x00000200/0x0200)) |
>  (( __u16)( __poll_t)0x00000010 < 0x0010 ? (v & ( __u16)( __poll_t)0x00000010) * (0x0010/( __u16)( __poll_t)0x00000010) : (v & ( __u16)( __poll_t)0x00000010) / (( __u16)( __poll_t)0x00000010/0x0010)) | (( __u16)( __poll_t)0x00002000 < 0x2000 ? (v & ( __u16)( __poll_t)0x00002000) * (0x2000/( __u16)( __poll_t)0x00002000) : (v & ( __u16)( __poll_t)0x00002000) / (( __u16)( __poll_t)0x00002000/0x2000)) | (( __u16)( __poll_t)0x00000400 < 0x0400 ? (v & ( __u16)( __poll_t)0x00000400) * (0x0400/( __u16)( __poll_t)0x00000400) : (v & ( __u16)( __poll_t)0x00000400) / (( __u16)( __poll_t)0x00000400/0x0400));
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __poll_t demangle_poll(u16 val)
>{
>
> return ( __poll_t)(0x0001 < ( __u16)( __poll_t)0x00000001 ? (val & 0x0001) * (( __u16)( __poll_t)0x00000001/0x0001) : (val & 0x0001) / (0x0001/( __u16)( __poll_t)0x00000001)) | ( __poll_t)(0x0004 < ( __u16)( __poll_t)0x00000004 ? (val & 0x0004) * (( __u16)( __poll_t)0x00000004/0x0004) : (val & 0x0004) / (0x0004/( __u16)( __poll_t)0x00000004)) | ( __poll_t)(0x0002 < ( __u16)( __poll_t)0x00000002 ? (val & 0x0002) * (( __u16)( __poll_t)0x00000002/0x0002) : (val & 0x0002) / (0x0002/( __u16)( __poll_t)0x00000002)) | ( __poll_t)(0x0008 < ( __u16)( __poll_t)0x00000008 ? (val & 0x0008) * (( __u16)( __poll_t)0x00000008/0x0008) : (val & 0x0008) / (0x0008/( __u16)( __poll_t)0x00000008)) | ( __poll_t)(0x0020 < ( __u16)( __poll_t)0x00000020 ? (val & 0x0020) * (( __u16)( __poll_t)0x00000020/0x0020) : (val & 0x0020) / (0x0020/( __u16)( __poll_t)0x00000020)) |
>  ( __poll_t)(0x0040 < ( __u16)( __poll_t)0x00000040 ? (val & 0x0040) * (( __u16)( __poll_t)0x00000040/0x0040) : (val & 0x0040) / (0x0040/( __u16)( __poll_t)0x00000040)) | ( __poll_t)(0x0080 < ( __u16)( __poll_t)0x00000080 ? (val & 0x0080) * (( __u16)( __poll_t)0x00000080/0x0080) : (val & 0x0080) / (0x0080/( __u16)( __poll_t)0x00000080)) | ( __poll_t)(0x0100 < ( __u16)( __poll_t)0x00000100 ? (val & 0x0100) * (( __u16)( __poll_t)0x00000100/0x0100) : (val & 0x0100) / (0x0100/( __u16)( __poll_t)0x00000100)) | ( __poll_t)(0x0200 < ( __u16)( __poll_t)0x00000200 ? (val & 0x0200) * (( __u16)( __poll_t)0x00000200/0x0200) : (val & 0x0200) / (0x0200/( __u16)( __poll_t)0x00000200)) |
>  ( __poll_t)(0x0010 < ( __u16)( __poll_t)0x00000010 ? (val & 0x0010) * (( __u16)( __poll_t)0x00000010/0x0010) : (val & 0x0010) / (0x0010/( __u16)( __poll_t)0x00000010)) | ( __poll_t)(0x2000 < ( __u16)( __poll_t)0x00002000 ? (val & 0x2000) * (( __u16)( __poll_t)0x00002000/0x2000) : (val & 0x2000) / (0x2000/( __u16)( __poll_t)0x00002000)) | ( __poll_t)(0x0400 < ( __u16)( __poll_t)0x00000400 ? (val & 0x0400) * (( __u16)( __poll_t)0x00000400/0x0400) : (val & 0x0400) / (0x0400/( __u16)( __poll_t)0x00000400));
>
>}
># 97 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/delay.h" 1
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/delay.h"
>extern unsigned long loops_per_jiffy;
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/delay.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/delay.h" 1
>
>
>
>
>
>extern void __bad_udelay(void);
>extern void __bad_ndelay(void);
>
>extern void __udelay(unsigned long usecs);
>extern void __ndelay(unsigned long nsecs);
>extern void __const_udelay(unsigned long xloops);
>extern void __delay(unsigned long loops);
># 6 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/delay.h" 2
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) use_tsc_delay(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) use_tpause_delay(void);
>void use_mwaitx_delay(void);
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/delay.h" 2
># 57 "/usr/src/linux-5.14.21-150500.53/include/linux/delay.h"
>extern unsigned long lpj_fine;
>void calibrate_delay(void);
>void __attribute__((weak)) calibration_delay_done(void);
>void msleep(unsigned int msecs);
>unsigned long msleep_interruptible(unsigned int msecs);
>void usleep_range_state(unsigned long min, unsigned long max,
>   unsigned int state);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void usleep_range(unsigned long min, unsigned long max)
>{
> usleep_range_state(min, max, 0x0002);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void usleep_idle_range(unsigned long min, unsigned long max)
>{
> usleep_range_state(min, max, (0x0002 | 0x0400));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ssleep(unsigned int seconds)
>{
> msleep(seconds * 1000);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fsleep(unsigned long usecs)
>{
> if (usecs <= 10)
>  ({ if (__builtin_constant_p(usecs)) { if ((usecs) / 20000 >= 1) __bad_udelay(); else __const_udelay((usecs) * 0x10c7ul); } else { __udelay(usecs); } });
> else if (usecs <= 20000)
>  usleep_range(usecs, 2 * usecs);
> else
>  msleep((((usecs) + (1000) - 1) / (1000)));
>}
># 98 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 117 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tlbflush.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tlbflush.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/invpcid.h" 1
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __invpcid(unsigned long pcid, unsigned long addr,
>        unsigned long type)
>{
> struct { u64 d[2]; } desc = { { pcid, addr } };
>
>
>
>
>
>
>
> asm volatile("invpcid %[desc], %[type]"
>       :: [desc] "m" (desc), [type] "r" (type) : "memory");
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void invpcid_flush_one(unsigned long pcid,
>         unsigned long addr)
>{
> __invpcid(pcid, addr, 0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void invpcid_flush_single_context(unsigned long pcid)
>{
> __invpcid(pcid, 0, 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void invpcid_flush_all(void)
>{
> __invpcid(0, 0, 2);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void invpcid_flush_all_nonglobals(void)
>{
> __invpcid(0, 0, 3);
>}
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tlbflush.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pti.h" 1
>
>
>
>
>
>
>extern void pti_init(void);
>extern void pti_check_boottime_disable(void);
>extern void pti_finalize(void);
># 14 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/tlbflush.h" 2
>
>
>void __flush_tlb_all(void);
>
>
>
>void cr4_update_irqsoff(unsigned long set, unsigned long clear);
>unsigned long cr4_read_shadow(void);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cr4_set_bits_irqsoff(unsigned long mask)
>{
> cr4_update_irqsoff(mask, 0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cr4_clear_bits_irqsoff(unsigned long mask)
>{
> cr4_update_irqsoff(0, mask);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cr4_set_bits(unsigned long mask)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> cr4_set_bits_irqsoff(mask);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cr4_clear_bits(unsigned long mask)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> cr4_clear_bits_irqsoff(mask);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
># 118 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 1
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>typedef unsigned long kernel_ulong_t;
>
>
>
>
>enum {
> PCI_ID_F_VFIO_DRIVER_OVERRIDE = 1,
>};
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct pci_device_id {
> __u32 vendor, device;
> __u32 subvendor, subdevice;
> __u32 class, class_mask;
> kernel_ulong_t driver_data;
> __u32 override_only;
>};
>
>
>
>
>
>
>
>struct ieee1394_device_id {
> __u32 match_flags;
> __u32 vendor_id;
> __u32 model_id;
> __u32 specifier_id;
> __u32 version;
> kernel_ulong_t driver_data;
>};
># 127 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct usb_device_id {
>
> __u16 match_flags;
>
>
> __u16 idVendor;
> __u16 idProduct;
> __u16 bcdDevice_lo;
> __u16 bcdDevice_hi;
>
>
> __u8 bDeviceClass;
> __u8 bDeviceSubClass;
> __u8 bDeviceProtocol;
>
>
> __u8 bInterfaceClass;
> __u8 bInterfaceSubClass;
> __u8 bInterfaceProtocol;
>
>
> __u8 bInterfaceNumber;
>
>
> kernel_ulong_t driver_info
>  __attribute__((aligned(sizeof(kernel_ulong_t))));
>};
># 172 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct hid_device_id {
> __u16 bus;
> __u16 group;
> __u32 vendor;
> __u32 product;
> kernel_ulong_t driver_data;
>};
>
>
>struct ccw_device_id {
> __u16 match_flags;
>
> __u16 cu_type;
> __u16 dev_type;
> __u8 cu_model;
> __u8 dev_model;
>
> kernel_ulong_t driver_info;
>};
>
>
>
>
>
>
>
>struct ap_device_id {
> __u16 match_flags;
> __u8 dev_type;
> kernel_ulong_t driver_info;
>};
>
>
>
>
>
>struct css_device_id {
> __u8 match_flags;
> __u8 type;
> kernel_ulong_t driver_data;
>};
>
>
>
>struct acpi_device_id {
> __u8 id[9];
> kernel_ulong_t driver_data;
> __u32 cls;
> __u32 cls_msk;
>};
>
>
>
>
>struct pnp_device_id {
> __u8 id[8];
> kernel_ulong_t driver_data;
>};
>
>struct pnp_card_device_id {
> __u8 id[8];
> kernel_ulong_t driver_data;
> struct {
>  __u8 id[8];
> } devs[8];
>};
>
>
>
>
>struct serio_device_id {
> __u8 type;
> __u8 extra;
> __u8 id;
> __u8 proto;
>};
>
>struct hda_device_id {
> __u32 vendor_id;
> __u32 rev_id;
> __u8 api_version;
> const char *name;
> unsigned long driver_data;
>};
>
>struct sdw_device_id {
> __u16 mfg_id;
> __u16 part_id;
> __u8 sdw_version;
> __u8 class_id;
> kernel_ulong_t driver_data;
>};
>
>
>
>
>struct of_device_id {
> char name[32];
> char type[32];
> char compatible[128];
> const void *data;
>};
>
>
>struct vio_device_id {
> char type[32];
> char compat[32];
>};
>
>
>
>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;
>};
># 348 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct input_device_id {
>
> kernel_ulong_t flags;
>
> __u16 bustype;
> __u16 vendor;
> __u16 product;
> __u16 version;
>
> kernel_ulong_t evbit[0x1f / 64 + 1];
> kernel_ulong_t keybit[0x2ff / 64 + 1];
> kernel_ulong_t relbit[0x0f / 64 + 1];
> kernel_ulong_t absbit[0x3f / 64 + 1];
> kernel_ulong_t mscbit[0x07 / 64 + 1];
> kernel_ulong_t ledbit[0x0f / 64 + 1];
> kernel_ulong_t sndbit[0x07 / 64 + 1];
> kernel_ulong_t ffbit[0x7f / 64 + 1];
> kernel_ulong_t swbit[0x10 / 64 + 1];
> kernel_ulong_t propbit[0x1f / 64 + 1];
>
> kernel_ulong_t driver_info;
>};
>
>
>
>
>
>
>struct eisa_device_id {
> char sig[8];
> kernel_ulong_t driver_data;
>};
>
>
>
>struct parisc_device_id {
> __u8 hw_type;
> __u8 hversion_rev;
> __u16 hversion;
> __u32 sversion;
>};
># 399 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct sdio_device_id {
> __u8 class;
> __u16 vendor;
> __u16 device;
> kernel_ulong_t driver_data;
>};
>
>
>struct ssb_device_id {
> __u16 vendor;
> __u16 coreid;
> __u8 revision;
> __u8 __pad;
>} __attribute__((packed, aligned(2)));
># 421 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct bcma_device_id {
> __u16 manuf;
> __u16 id;
> __u8 rev;
> __u8 class;
>} __attribute__((packed,aligned(2)));
># 435 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct virtio_device_id {
> __u32 device;
> __u32 vendor;
>};
>
>
>
>
>
>struct hv_vmbus_device_id {
> guid_t guid;
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>struct rpmsg_device_id {
> char name[32];
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>struct i2c_device_id {
> char name[20];
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>struct pci_epf_device_id {
> char name[20];
> kernel_ulong_t driver_data;
>};
># 486 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct i3c_device_id {
> __u8 match_flags;
> __u8 dcr;
> __u16 manuf_id;
> __u16 part_id;
> __u16 extra_info;
>
> const void *data;
>};
>
>
>
>
>
>
>struct spi_device_id {
> char name[32];
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>struct slim_device_id {
> __u16 manf_id, prod_code;
> __u16 dev_index, instance;
>
>
> kernel_ulong_t driver_data;
>};
>
>
>
>
>struct apr_device_id {
> char name[32];
> __u32 domain_id;
> __u32 svc_id;
> __u32 svc_version;
> kernel_ulong_t driver_data;
>};
>
>
>
>
>struct spmi_device_id {
> char name[32];
> kernel_ulong_t driver_data;
>};
>
>
>enum dmi_field {
> DMI_NONE,
> DMI_BIOS_VENDOR,
> DMI_BIOS_VERSION,
> DMI_BIOS_DATE,
> DMI_BIOS_RELEASE,
> DMI_EC_FIRMWARE_RELEASE,
> DMI_SYS_VENDOR,
> DMI_PRODUCT_NAME,
> DMI_PRODUCT_VERSION,
> DMI_PRODUCT_SERIAL,
> DMI_PRODUCT_UUID,
> DMI_PRODUCT_SKU,
> DMI_PRODUCT_FAMILY,
> DMI_BOARD_VENDOR,
> DMI_BOARD_NAME,
> DMI_BOARD_VERSION,
> DMI_BOARD_SERIAL,
> DMI_BOARD_ASSET_TAG,
> DMI_CHASSIS_VENDOR,
> DMI_CHASSIS_TYPE,
> DMI_CHASSIS_VERSION,
> DMI_CHASSIS_SERIAL,
> DMI_CHASSIS_ASSET_TAG,
> DMI_STRING_MAX,
> DMI_OEM_STRING,
>};
>
>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;
>};
># 593 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct platform_device_id {
> char name[20];
> kernel_ulong_t driver_data;
>};
># 620 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct mdio_device_id {
> __u32 phy_id;
> __u32 phy_id_mask;
>};
>
>struct zorro_device_id {
> __u32 id;
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>struct isapnp_device_id {
> unsigned short card_vendor, card_device;
> unsigned short vendor, function;
> kernel_ulong_t driver_data;
>};
># 649 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct amba_id {
> unsigned int id;
> unsigned int mask;
> void *data;
>};
>
>
>
>
>
>struct mips_cdmm_device_id {
> __u8 type;
>};
># 673 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct x86_cpu_id {
> __u16 vendor;
> __u16 family;
> __u16 model;
> __u16 steppings;
> __u16 feature;
> kernel_ulong_t driver_data;
>};
># 694 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct cpu_feature {
> __u16 feature;
>};
>
>
>
>struct ipack_device_id {
> __u8 format;
> __u32 vendor;
> __u32 device;
>};
># 719 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct mei_cl_device_id {
> char name[32];
> uuid_le uuid;
> __u8 version;
> kernel_ulong_t driver_info;
>};
># 740 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct rio_device_id {
> __u16 did, vid;
> __u16 asm_did, asm_vid;
>};
>
>struct mcb_device_id {
> __u16 device;
> kernel_ulong_t driver_data;
>};
>
>struct ulpi_device_id {
> __u16 vendor;
> __u16 product;
> kernel_ulong_t driver_data;
>};
># 764 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct fsl_mc_device_id {
> __u16 vendor;
> const char obj_type[16];
>};
># 782 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct tb_service_id {
> __u32 match_flags;
> char protocol_key[8 + 1];
> __u32 protocol_id;
> __u32 protocol_version;
> __u32 protocol_revision;
> kernel_ulong_t driver_data;
>};
># 806 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct typec_device_id {
> __u16 svid;
> __u8 mode;
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>struct tee_client_device_id {
> uuid_t uuid;
>};
># 830 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct wmi_device_id {
> const char guid_string[36 +1];
> const void *context;
>};
># 843 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct mhi_device_id {
> const char chan[32];
> kernel_ulong_t driver_data;
>};
>
>
>
>
>struct auxiliary_device_id {
> char name[32];
> kernel_ulong_t driver_data;
>};
>
>
>
>
>
>
>
>struct ssam_device_id {
> __u8 match_flags;
>
> __u8 domain;
> __u8 category;
> __u8 target;
> __u8 instance;
> __u8 function;
>
> kernel_ulong_t driver_data;
>};
># 892 "/usr/src/linux-5.14.21-150500.53/include/linux/mod_devicetable.h"
>struct dfl_device_id {
> __u16 type;
> __u16 feature_id;
> kernel_ulong_t driver_data;
>};
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/irqreturn.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/irqreturn.h"
>enum irqreturn {
> IRQ_NONE = (0 << 0),
> IRQ_HANDLED = (1 << 0),
> IRQ_WAKE_THREAD = (1 << 1),
>};
>
>typedef enum irqreturn irqreturn_t;
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/context_tracking_state.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/static_key.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/context_tracking_state.h" 2
>
>struct context_tracking {
>
>
>
>
>
>
> bool active;
> int recursion;
> enum ctx_state {
>  CONTEXT_DISABLED = -1,
>  CONTEXT_KERNEL = 0,
>  CONTEXT_USER,
>  CONTEXT_GUEST,
> } state;
>};
>
>
>extern struct static_key_false context_tracking_key;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_context_tracking; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct context_tracking) context_tracking;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool context_tracking_enabled(void)
>{
> return ({ bool branch; if (__builtin_types_compatible_p(typeof(*&context_tracking_key), struct static_key_true)) branch = arch_static_branch_jump(&(&context_tracking_key)->key, false); else if (__builtin_types_compatible_p(typeof(*&context_tracking_key), struct static_key_false)) branch = arch_static_branch(&(&context_tracking_key)->key, false); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool context_tracking_enabled_cpu(int cpu)
>{
> return context_tracking_enabled() && (*({ do { const void *__vpp_verify = (typeof((&(context_tracking.active)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(context_tracking.active)))) *)((&(context_tracking.active))))); (typeof((typeof(*((&(context_tracking.active)))) *)((&(context_tracking.active))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool context_tracking_enabled_this_cpu(void)
>{
> return context_tracking_enabled() && ({ __this_cpu_preempt_check("read"); ({ typeof(context_tracking.active) pscr_ret__; do { const void *__vpp_verify = (typeof((&(context_tracking.active)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(context_tracking.active)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (context_tracking.active)); (typeof(context_tracking.active))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (context_tracking.active)); (typeof(context_tracking.active))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (context_tracking.active)); (typeof(context_tracking.active))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (context_tracking.active)); (typeof(context_tracking.active))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool context_tracking_in_user(void)
>{
> return ({ __this_cpu_preempt_check("read"); ({ typeof(context_tracking.state) pscr_ret__; do { const void *__vpp_verify = (typeof((&(context_tracking.state)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(context_tracking.state)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (context_tracking.state)); (typeof(context_tracking.state))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (context_tracking.state)); (typeof(context_tracking.state))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (context_tracking.state)); (typeof(context_tracking.state))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (context_tracking.state)); (typeof(context_tracking.state))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }) == CONTEXT_USER;
>}
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace_irq.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace_irq.h"
>extern bool trace_osnoise_callback_enabled;
>extern void trace_osnoise_callback(bool enter);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ftrace_nmi_enter(void)
>{
>
>
>
>
>
> if (trace_osnoise_callback_enabled)
>  trace_osnoise_callback(true);
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ftrace_nmi_exit(void)
>{
>
>
>
>
>
> if (trace_osnoise_callback_enabled)
>  trace_osnoise_callback(false);
>
>}
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/vtime.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/vtime.h"
>extern void vtime_account_kernel(struct task_struct *tsk);
>extern void vtime_account_idle(struct task_struct *tsk);
>
>
>
>extern void arch_vtime_task_switch(struct task_struct *tsk);
>extern void vtime_user_enter(struct task_struct *tsk);
>extern void vtime_user_exit(struct task_struct *tsk);
>extern void vtime_guest_enter(struct task_struct *tsk);
>extern void vtime_guest_exit(struct task_struct *tsk);
>extern void vtime_init_idle(struct task_struct *tsk, int cpu);
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/vtime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vtime_account_irq(struct task_struct *tsk, unsigned int offset) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vtime_account_softirq(struct task_struct *tsk) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vtime_account_hardirq(struct task_struct *tsk) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vtime_flush(struct task_struct *tsk) { }
># 75 "/usr/src/linux-5.14.21-150500.53/include/linux/vtime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vtime_accounting_enabled(void)
>{
> return context_tracking_enabled();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vtime_accounting_enabled_cpu(int cpu)
>{
> return context_tracking_enabled_cpu(cpu);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vtime_accounting_enabled_this_cpu(void)
>{
> return context_tracking_enabled_this_cpu();
>}
>
>extern void vtime_task_switch_generic(struct task_struct *prev);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vtime_task_switch(struct task_struct *prev)
>{
> if (vtime_accounting_enabled_this_cpu())
>  vtime_task_switch_generic(prev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void vtime_account_guest_enter(void)
>{
> if (vtime_accounting_enabled_this_cpu())
>  vtime_guest_enter(get_current());
> else
>  get_current()->flags |= 0x00000001;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void vtime_account_guest_exit(void)
>{
> if (vtime_accounting_enabled_this_cpu())
>  vtime_guest_exit(get_current());
> else
>  get_current()->flags &= ~0x00000001;
>}
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/vtime.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void irqtime_account_irq(struct task_struct *tsk, unsigned int offset) { }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void account_softirq_enter(struct task_struct *tsk)
>{
> vtime_account_irq(tsk, (1UL << (0 + 8)));
> irqtime_account_irq(tsk, (1UL << (0 + 8)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void account_softirq_exit(struct task_struct *tsk)
>{
> vtime_account_softirq(tsk);
> irqtime_account_irq(tsk, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void account_hardirq_enter(struct task_struct *tsk)
>{
> vtime_account_irq(tsk, (1UL << ((0 + 8) + 8)));
> irqtime_account_irq(tsk, (1UL << ((0 + 8) + 8)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void account_hardirq_exit(struct task_struct *tsk)
>{
> vtime_account_hardirq(tsk);
> irqtime_account_irq(tsk, 0);
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/hardirq.h" 1
>
>
>
>
>
>
>typedef struct {
> u16 __softirq_pending;
>
> u8 kvm_cpu_l1tf_flush_l1d;
>
> 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 kvm_posted_intr_nested_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;
>
>
> unsigned int irq_hv_callback_count;
>
>
> unsigned int irq_hv_reenlightenment_count;
> unsigned int hyperv_stimer0_count;
>
>} __attribute__((__aligned__((1 << (6))))) irq_cpustat_t;
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_irq_stat; extern __attribute__((section(".data..percpu" ""))) __typeof__(irq_cpustat_t) irq_stat __attribute__((__aligned__((1 << (6)))));
>
>
>
>
>
>extern void ack_bad_irq(unsigned int irq);
>
>extern u64 arch_irq_stat_cpu(unsigned int cpu);
>
>
>extern u64 arch_irq_stat(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kvm_set_cpu_l1tf_flush_l1d(void)
>{
> ({ __this_cpu_preempt_check("write"); do { do { const void *__vpp_verify = (typeof((&(irq_stat.kvm_cpu_l1tf_flush_l1d)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(irq_stat.kvm_cpu_l1tf_flush_l1d)) { case 1: do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("mov" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "qi" (pto_val__)); } while (0);break; case 2: do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("mov" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "ri" (pto_val__)); } while (0);break; case 4: do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("mov" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "ri" (pto_val__)); } while (0);break; case 8: do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("mov" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "re" (pto_val__)); } while (0);break; default: __bad_size_call_parameter();break; } } while (0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void kvm_clear_cpu_l1tf_flush_l1d(void)
>{
> ({ __this_cpu_preempt_check("write"); do { do { const void *__vpp_verify = (typeof((&(irq_stat.kvm_cpu_l1tf_flush_l1d)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(irq_stat.kvm_cpu_l1tf_flush_l1d)) { case 1: do { u8 pto_val__ = ((u8)(((unsigned long) 0) & 0xff)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (0); (void)pto_tmp__; } asm ("mov" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "qi" (pto_val__)); } while (0);break; case 2: do { u16 pto_val__ = ((u16)(((unsigned long) 0) & 0xffff)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (0); (void)pto_tmp__; } asm ("mov" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "ri" (pto_val__)); } while (0);break; case 4: do { u32 pto_val__ = ((u32)(((unsigned long) 0) & 0xffffffff)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (0); (void)pto_tmp__; } asm ("mov" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "ri" (pto_val__)); } while (0);break; case 8: do { u64 pto_val__ = ((u64)(0)); if (0) { typeof((irq_stat.kvm_cpu_l1tf_flush_l1d)) pto_tmp__; pto_tmp__ = (0); (void)pto_tmp__; } asm ("mov" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((irq_stat.kvm_cpu_l1tf_flush_l1d)) : [val] "re" (pto_val__)); } while (0);break; default: __bad_size_call_parameter();break; } } while (0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool kvm_get_cpu_l1tf_flush_l1d(void)
>{
> return ({ __this_cpu_preempt_check("read"); ({ typeof(irq_stat.kvm_cpu_l1tf_flush_l1d) pscr_ret__; do { const void *__vpp_verify = (typeof((&(irq_stat.kvm_cpu_l1tf_flush_l1d)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(irq_stat.kvm_cpu_l1tf_flush_l1d)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (irq_stat.kvm_cpu_l1tf_flush_l1d)); (typeof(irq_stat.kvm_cpu_l1tf_flush_l1d))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (irq_stat.kvm_cpu_l1tf_flush_l1d)); (typeof(irq_stat.kvm_cpu_l1tf_flush_l1d))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (irq_stat.kvm_cpu_l1tf_flush_l1d)); (typeof(irq_stat.kvm_cpu_l1tf_flush_l1d))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (irq_stat.kvm_cpu_l1tf_flush_l1d)); (typeof(irq_stat.kvm_cpu_l1tf_flush_l1d))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); });
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h" 2
>
>extern void synchronize_irq(unsigned int irq);
>extern bool synchronize_hardirq(unsigned int irq);
>
>
>void __rcu_irq_enter_check_tick(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void rcu_irq_enter_check_tick(void)
>{
> if (context_tracking_enabled())
>  __rcu_irq_enter_check_tick();
>}
># 55 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h"
>void irq_enter(void);
>
>
>
>void irq_enter_rcu(void);
># 83 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h"
>void irq_exit(void);
>
>
>
>
>void irq_exit_rcu(void);
># 99 "/usr/src/linux-5.14.21-150500.53/include/linux/hardirq.h"
>extern void rcu_nmi_enter(void);
>extern void rcu_nmi_exit(void);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h" 2
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irq.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irq.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irq_vectors.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irq.h" 2
># 21 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/irq.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int irq_canonicalize(int irq)
>{
> return ((irq == 2) ? 9 : irq);
>}
>
>extern int irq_init_percpu_irqstack(unsigned int cpu);
>
>struct irq_desc;
>
>extern void fixup_irqs(void);
>
>
>extern void kvm_set_posted_intr_wakeup_handler(void (*handler)(void));
>
>
>extern void (*x86_platform_ipi_callback)(void);
>extern void native_init_IRQ(void);
>
>extern void __handle_irq(struct irq_desc *desc, struct pt_regs *regs);
>
>extern void init_ISA_irqs(void);
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) init_IRQ(void);
>
>
>void arch_trigger_cpumask_backtrace(const struct cpumask *mask,
>        bool exclude_self);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/sections.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h" 1
># 35 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>extern char _text[], _stext[], _etext[];
>extern char _data[], _sdata[], _edata[];
>extern char __bss_start[], __bss_stop[];
>extern char __init_begin[], __init_end[];
>extern char _sinittext[], _einittext[];
>extern char __start_ro_after_init[], __end_ro_after_init[];
>extern char _end[];
>extern char __per_cpu_load[], __per_cpu_start[], __per_cpu_end[];
>extern char __kprobes_text_start[], __kprobes_text_end[];
>extern char __entry_text_start[], __entry_text_end[];
>extern char __start_rodata[], __end_rodata[];
>extern char __irqentry_text_start[], __irqentry_text_end[];
>extern char __softirqentry_text_start[], __softirqentry_text_end[];
>extern char __start_once[], __end_once[];
>
>
>extern char __ctors_start[], __ctors_end[];
>
>
>extern char __start_opd[], __end_opd[];
>
>
>extern char __noinstr_text_start[], __noinstr_text_end[];
>
>extern __attribute__((__externally_visible__)) const void __nosave_begin, __nosave_end;
># 70 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_is_kernel_text(unsigned long addr)
>{
> return 0;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_is_kernel_data(unsigned long addr)
>{
> return 0;
>}
># 94 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool memory_contains(void *begin, void *end, void *virt,
>       size_t size)
>{
> return virt >= begin && virt + size <= end;
>}
># 111 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool memory_intersects(void *begin, void *end, void *virt,
>         size_t size)
>{
> void *vend = virt + size;
>
> if (virt < end && vend > begin)
>  return true;
>
> return false;
>}
># 131 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool init_section_contains(void *virt, size_t size)
>{
> return memory_contains(__init_begin, __init_end, virt, size);
>}
># 145 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool init_section_intersects(void *virt, size_t size)
>{
> return memory_intersects(__init_begin, __init_end, virt, size);
>}
># 158 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/sections.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_kernel_rodata(unsigned long addr)
>{
> return addr >= (unsigned long)__start_rodata &&
>        addr < (unsigned long)__end_rodata;
>}
># 8 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/sections.h" 2
>
>
>extern char __brk_base[], __brk_limit[];
>extern char __end_rodata_aligned[];
>
>
>extern char __end_rodata_hpage_align[];
>
>
>extern char __end_of_kernel_reserve[];
>
>extern unsigned long _brk_start, _brk_end;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_is_kernel_initmem_freed(unsigned long addr)
>{
>
>
>
>
> if (_brk_start)
>  return 0;
>
>
>
>
>
> return addr >= _brk_end && addr < (unsigned long)&_end;
>}
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h" 2
># 95 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>enum {
> IRQC_IS_HARDIRQ = 0,
> IRQC_IS_NESTED,
>};
>
>typedef irqreturn_t (*irq_handler_t)(int, void *);
># 118 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>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;
> unsigned long thread_flags;
> unsigned long thread_mask;
> const char *name;
> struct proc_dir_entry *dir;
>} __attribute__((__aligned__(1 << (6))));
>
>extern irqreturn_t no_action(int cpl, void *dev_id);
># 146 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>extern int __attribute__((__warn_unused_result__))
>request_threaded_irq(unsigned int irq, irq_handler_t handler,
>       irq_handler_t thread_fn,
>       unsigned long flags, const char *name, void *dev);
># 164 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__))
>request_irq(unsigned int irq, irq_handler_t handler, unsigned long flags,
>     const char *name, void *dev)
>{
> return request_threaded_irq(irq, handler, ((void *)0), flags, name, dev);
>}
>
>extern int __attribute__((__warn_unused_result__))
>request_any_context_irq(unsigned int irq, irq_handler_t handler,
>   unsigned long flags, const char *name, void *dev_id);
>
>extern int __attribute__((__warn_unused_result__))
>__request_percpu_irq(unsigned int irq, irq_handler_t handler,
>       unsigned long flags, const char *devname,
>       void *percpu_dev_id);
>
>extern int __attribute__((__warn_unused_result__))
>request_nmi(unsigned int irq, irq_handler_t handler, unsigned long flags,
>     const char *name, void *dev);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__))
>request_percpu_irq(unsigned int irq, irq_handler_t handler,
>     const char *devname, void *percpu_dev_id)
>{
> return __request_percpu_irq(irq, handler, 0,
>        devname, percpu_dev_id);
>}
>
>extern int __attribute__((__warn_unused_result__))
>request_percpu_nmi(unsigned int irq, irq_handler_t handler,
>     const char *devname, void *dev);
>
>extern const void *free_irq(unsigned int, void *);
>extern void free_percpu_irq(unsigned int, void *);
>
>extern const void *free_nmi(unsigned int irq, void *dev_id);
>extern void free_percpu_nmi(unsigned int irq, void *percpu_dev_id);
>
>struct device;
>
>extern int __attribute__((__warn_unused_result__))
>devm_request_threaded_irq(struct device *dev, unsigned int irq,
>     irq_handler_t handler, irq_handler_t thread_fn,
>     unsigned long irqflags, const char *devname,
>     void *dev_id);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __attribute__((__warn_unused_result__))
>devm_request_irq(struct device *dev, unsigned int irq, irq_handler_t handler,
>   unsigned long irqflags, const char *devname, void *dev_id)
>{
> return devm_request_threaded_irq(dev, irq, handler, ((void *)0), irqflags,
>      devname, dev_id);
>}
>
>extern int __attribute__((__warn_unused_result__))
>devm_request_any_context_irq(struct device *dev, unsigned int irq,
>   irq_handler_t handler, unsigned long irqflags,
>   const char *devname, void *dev_id);
>
>extern void devm_free_irq(struct device *dev, unsigned int irq, void *dev_id);
># 243 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>bool irq_has_action(unsigned int irq);
>extern void disable_irq_nosync(unsigned int irq);
>extern bool disable_hardirq(unsigned int irq);
>extern void disable_irq(unsigned int irq);
>extern void disable_percpu_irq(unsigned int irq);
>extern void enable_irq(unsigned int irq);
>extern void enable_percpu_irq(unsigned int irq, unsigned int type);
>extern bool irq_percpu_is_enabled(unsigned int irq);
>extern void irq_wake_thread(unsigned int irq, void *dev_id);
>
>extern void disable_nmi_nosync(unsigned int irq);
>extern void disable_percpu_nmi(unsigned int irq);
>extern void enable_nmi(unsigned int irq);
>extern void enable_percpu_nmi(unsigned int irq, unsigned int type);
>extern int prepare_percpu_nmi(unsigned int irq);
>extern void teardown_percpu_nmi(unsigned int irq);
>
>extern int irq_inject_interrupt(unsigned int irq);
>
>
>extern void suspend_device_irqs(void);
>extern void resume_device_irqs(void);
>extern void rearm_wake_irq(unsigned int irq);
># 279 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>struct irq_affinity_notify {
> unsigned int irq;
> struct kref kref;
> struct work_struct work;
> void (*notify)(struct irq_affinity_notify *, const cpumask_t *mask);
> void (*release)(struct kref *ref);
>};
># 303 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>struct irq_affinity {
> unsigned int pre_vectors;
> unsigned int post_vectors;
> unsigned int nr_sets;
> unsigned int set_size[4];
> void (*calc_sets)(struct irq_affinity *, unsigned int nvecs);
> void *priv;
>};
>
>
>
>
>
>
>struct irq_affinity_desc {
> struct cpumask mask;
> unsigned int is_managed : 1;
>};
>
>
>
>extern cpumask_var_t irq_default_affinity;
>
>extern int irq_set_affinity(unsigned int irq, const struct cpumask *cpumask);
>extern int irq_force_affinity(unsigned int irq, const struct cpumask *cpumask);
>
>extern int irq_can_set_affinity(unsigned int irq);
>extern int irq_select_affinity(unsigned int irq);
>
>extern int __irq_apply_affinity_hint(unsigned int irq, const struct cpumask *m,
>         bool setaffinity);
># 342 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>irq_update_affinity_hint(unsigned int irq, const struct cpumask *m)
>{
> return __irq_apply_affinity_hint(irq, m, false);
>}
># 357 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>irq_set_affinity_and_hint(unsigned int irq, const struct cpumask *m)
>{
> return __irq_apply_affinity_hint(irq, m, true);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int irq_set_affinity_hint(unsigned int irq, const struct cpumask *m)
>{
> return irq_set_affinity_and_hint(irq, m);
>}
>
>extern int irq_update_affinity_desc(unsigned int irq,
>        struct irq_affinity_desc *affinity);
>
>extern int
>irq_set_affinity_notifier(unsigned int irq, struct irq_affinity_notify *notify);
>
>struct irq_affinity_desc *
>irq_create_affinity_masks(unsigned int nvec, struct irq_affinity *affd);
>
>unsigned int irq_calc_affinity_vectors(unsigned int minvec, unsigned int maxvec,
>           const struct irq_affinity *affd);
># 459 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void disable_irq_nosync_lockdep(unsigned int irq)
>{
> disable_irq_nosync(irq);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void disable_irq_nosync_lockdep_irqsave(unsigned int irq, unsigned long *flags)
>{
> disable_irq_nosync(irq);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void disable_irq_lockdep(unsigned int irq)
>{
> disable_irq(irq);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void enable_irq_lockdep(unsigned int irq)
>{
>
>
>
> enable_irq(irq);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void enable_irq_lockdep_irqrestore(unsigned int irq, unsigned long *flags)
>{
>
>
>
> enable_irq(irq);
>}
>
>
>extern int irq_set_irq_wake(unsigned int irq, unsigned int on);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int enable_irq_wake(unsigned int irq)
>{
> return irq_set_irq_wake(irq, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int disable_irq_wake(unsigned int irq)
>{
> return irq_set_irq_wake(irq, 0);
>}
>
>
>
>
>enum irqchip_irq_state {
> IRQCHIP_STATE_PENDING,
> IRQCHIP_STATE_ACTIVE,
> IRQCHIP_STATE_MASKED,
> IRQCHIP_STATE_LINE_LEVEL,
>};
>
>extern int irq_get_irqchip_state(unsigned int irq, enum irqchip_irq_state which,
>     bool *state);
>extern int irq_set_irqchip_state(unsigned int irq, enum irqchip_irq_state which,
>     bool state);
>
>
>
>
>
>extern struct static_key_false force_irqthreads_key;
># 566 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>enum
>{
> HI_SOFTIRQ=0,
> TIMER_SOFTIRQ,
> NET_TX_SOFTIRQ,
> NET_RX_SOFTIRQ,
> BLOCK_SOFTIRQ,
> IRQ_POLL_SOFTIRQ,
> TASKLET_SOFTIRQ,
> SCHED_SOFTIRQ,
> HRTIMER_SOFTIRQ,
> RCU_SOFTIRQ,
>
> NR_SOFTIRQS
>};
>
>
>
>
>
>
>extern const char * const softirq_to_name[NR_SOFTIRQS];
>
>
>
>
>
>struct softirq_action
>{
> void (*action)(struct softirq_action *);
>};
>
> void do_softirq(void);
> void __do_softirq(void);
>
>extern void open_softirq(int nr, void (*action)(struct softirq_action *));
>extern void softirq_init(void);
>extern void __raise_softirq_irqoff(unsigned int nr);
>
>extern void raise_softirq_irqoff(unsigned int nr);
>extern void raise_softirq(unsigned int nr);
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_ksoftirqd; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct task_struct *) ksoftirqd;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct task_struct *this_cpu_ksoftirqd(void)
>{
> return ({ typeof(ksoftirqd) pscr_ret__; do { const void *__vpp_verify = (typeof((&(ksoftirqd)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(ksoftirqd)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm volatile ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (ksoftirqd)); (typeof(ksoftirqd))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm volatile ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (ksoftirqd)); (typeof(ksoftirqd))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm volatile ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (ksoftirqd)); (typeof(ksoftirqd))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm volatile ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (ksoftirqd)); (typeof(ksoftirqd))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; });
>}
># 638 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>struct tasklet_struct
>{
> struct tasklet_struct *next;
> unsigned long state;
> atomic_t count;
> bool use_callback;
> union {
>  void (*func)(unsigned long data);
>  void (*callback)(struct tasklet_struct *t);
> };
> unsigned long data;
>};
># 680 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>enum
>{
> TASKLET_STATE_SCHED,
> TASKLET_STATE_RUN
>};
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int tasklet_trylock(struct tasklet_struct *t)
>{
> return !test_and_set_bit(TASKLET_STATE_RUN, &(t)->state);
>}
>
>void tasklet_unlock(struct tasklet_struct *t);
>void tasklet_unlock_wait(struct tasklet_struct *t);
>void tasklet_unlock_spin_wait(struct tasklet_struct *t);
># 703 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>extern void __tasklet_schedule(struct tasklet_struct *t);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tasklet_schedule(struct tasklet_struct *t)
>{
> if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
>  __tasklet_schedule(t);
>}
>
>extern void __tasklet_hi_schedule(struct tasklet_struct *t);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tasklet_hi_schedule(struct tasklet_struct *t)
>{
> if (!test_and_set_bit(TASKLET_STATE_SCHED, &t->state))
>  __tasklet_hi_schedule(t);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tasklet_disable_nosync(struct tasklet_struct *t)
>{
> atomic_inc(&t->count);
> do { } while (0);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tasklet_disable_in_atomic(struct tasklet_struct *t)
>{
> tasklet_disable_nosync(t);
> tasklet_unlock_spin_wait(t);
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tasklet_disable(struct tasklet_struct *t)
>{
> tasklet_disable_nosync(t);
> tasklet_unlock_wait(t);
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tasklet_enable(struct tasklet_struct *t)
>{
> do { } while (0);
> atomic_dec(&t->count);
>}
>
>extern void tasklet_kill(struct tasklet_struct *t);
>extern void tasklet_init(struct tasklet_struct *t,
>    void (*func)(unsigned long), unsigned long data);
>extern void tasklet_setup(struct tasklet_struct *t,
>     void (*callback)(struct tasklet_struct *));
># 797 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>extern unsigned long probe_irq_on(void);
>extern int probe_irq_off(unsigned long);
>extern unsigned int probe_irq_mask(unsigned long);
>
>
>
>
>extern void init_irq_proc(void);
># 817 "/usr/src/linux-5.14.21-150500.53/include/linux/interrupt.h"
>struct seq_file;
>int show_interrupts(struct seq_file *p, void *v);
>int arch_show_interrupts(struct seq_file *p, int prec);
>
>extern int early_irq_init(void);
>extern int arch_probe_nr_irqs(void);
>extern int arch_early_irq_init(void);
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h" 1
># 45 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
># 1 "./arch/x86/include/generated/asm/early_ioremap.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/early_ioremap.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/early_ioremap.h"
>extern void *early_ioremap(resource_size_t phys_addr,
>       unsigned long size);
>extern void *early_memremap(resource_size_t phys_addr,
>       unsigned long size);
>extern void *early_memremap_ro(resource_size_t phys_addr,
>          unsigned long size);
>extern void *early_memremap_prot(resource_size_t phys_addr,
>     unsigned long size, unsigned long prot_val);
>extern void early_iounmap(void *addr, unsigned long size);
>extern void early_memunmap(void *addr, unsigned long size);
>
>
>
>
>
>extern void early_ioremap_shutdown(void);
>
>
>
>extern void early_ioremap_init(void);
>
>
>extern void early_ioremap_setup(void);
>
>
>
>
>
>extern void early_ioremap_reset(void);
>
>
>
>
>extern void copy_from_early_mem(void *dest, phys_addr_t src,
>    unsigned long size);
># 1 "./arch/x86/include/generated/asm/early_ioremap.h" 2
># 46 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/shared/io.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/shared/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __outb(u8 value, u16 port) { asm volatile("out" "b" " %" "b" "0, %w1" : : "a"(value), "Nd"(port)); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 __inb(u16 port) { u8 value; asm volatile("in" "b" " %w1, %" "b" "0" : "=a"(value) : "Nd"(port)); return value; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __outw(u16 value, u16 port) { asm volatile("out" "w" " %" "w" "0, %w1" : : "a"(value), "Nd"(port)); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 __inw(u16 port) { u16 value; asm volatile("in" "w" " %w1, %" "w" "0" : "=a"(value) : "Nd"(port)); return value; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __outl(u32 value, u16 port) { asm volatile("out" "l" " %" "" "0, %w1" : : "a"(value), "Nd"(port)); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 __inl(u16 port) { u32 value; asm volatile("in" "l" " %w1, %" "" "0" : "=a"(value) : "Nd"(port)); return value; }
># 48 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h" 2
># 59 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char readb(const volatile void *addr) { unsigned char ret; asm volatile("mov" "b" " %1,%0":"=q" (ret) :"m" (*(volatile unsigned char *)addr) :"memory"); return ret; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned short readw(const volatile void *addr) { unsigned short ret; asm volatile("mov" "w" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned short *)addr) :"memory"); return ret; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int readl(const volatile void *addr) { unsigned int ret; asm volatile("mov" "l" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned int *)addr) :"memory"); return ret; }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char __readb(const volatile void *addr) { unsigned char ret; asm volatile("mov" "b" " %1,%0":"=q" (ret) :"m" (*(volatile unsigned char *)addr) ); return ret; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned short __readw(const volatile void *addr) { unsigned short ret; asm volatile("mov" "w" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned short *)addr) ); return ret; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __readl(const volatile void *addr) { unsigned int ret; asm volatile("mov" "l" " %1,%0":"=r" (ret) :"m" (*(volatile unsigned int *)addr) ); return ret; }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writeb(unsigned char val, volatile void *addr) { asm volatile("mov" "b" " %0,%1": :"q" (val), "m" (*(volatile unsigned char *)addr) :"memory"); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writew(unsigned short val, volatile void *addr) { asm volatile("mov" "w" " %0,%1": :"r" (val), "m" (*(volatile unsigned short *)addr) :"memory"); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writel(unsigned int val, volatile void *addr) { asm volatile("mov" "l" " %0,%1": :"r" (val), "m" (*(volatile unsigned int *)addr) :"memory"); }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __writeb(unsigned char val, volatile void *addr) { asm volatile("mov" "b" " %0,%1": :"q" (val), "m" (*(volatile unsigned char *)addr) ); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __writew(unsigned short val, volatile void *addr) { asm volatile("mov" "w" " %0,%1": :"r" (val), "m" (*(volatile unsigned short *)addr) ); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __writel(unsigned int val, volatile void *addr) { asm volatile("mov" "l" " %0,%1": :"r" (val), "m" (*(volatile unsigned int *)addr) ); }
># 97 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 readq(const volatile void *addr) { u64 ret; asm volatile("mov" "q" " %1,%0":"=r" (ret) :"m" (*(volatile u64 *)addr) :"memory"); return ret; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 __readq(const volatile void *addr) { u64 ret; asm volatile("mov" "q" " %1,%0":"=r" (ret) :"m" (*(volatile u64 *)addr) ); return ret; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writeq(u64 val, volatile void *addr) { asm volatile("mov" "q" " %0,%1": :"r" (val), "m" (*(volatile u64 *)addr) :"memory"); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __writeq(u64 val, volatile void *addr) { asm volatile("mov" "q" " %0,%1": :"r" (val), "m" (*(volatile u64 *)addr) ); }
># 115 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>extern int valid_phys_addr_range(phys_addr_t addr, size_t size);
>extern int valid_mmap_phys_addr_range(unsigned long pfn, size_t size);
># 131 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) phys_addr_t virt_to_phys(volatile void *address)
>{
> return __phys_addr_nodebug((unsigned long)(address));
>}
># 150 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *phys_to_virt(phys_addr_t address)
>{
> return ((void *)((unsigned long)(address)+((unsigned long)page_offset_base)));
>}
># 166 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int isa_virt_to_bus(volatile void *address)
>{
> return (unsigned int)virt_to_phys(address);
>}
># 185 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>extern void *ioremap_uc(resource_size_t offset, unsigned long size);
>
>extern void *ioremap_cache(resource_size_t offset, unsigned long size);
>
>extern void *ioremap_prot(resource_size_t offset, unsigned long size, unsigned long prot_val);
>
>extern void *ioremap_encrypted(resource_size_t phys_addr, unsigned long size);
># 208 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>void *ioremap(resource_size_t offset, unsigned long size);
>
>
>extern void iounmap(volatile void *addr);
>
>
>extern void set_iounmap_nonlazy(void);
>
>
>
>void memcpy_fromio(void *, const volatile void *, size_t);
>void memcpy_toio(volatile void *, const void *, size_t);
>void memset_io(volatile void *, int, size_t);
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/iomap.h" 1
># 29 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/iomap.h"
>extern unsigned int ioread8(const void *);
>extern unsigned int ioread16(const void *);
>extern unsigned int ioread16be(const void *);
>extern unsigned int ioread32(const void *);
>extern unsigned int ioread32be(const void *);
>
>extern u64 ioread64(const void *);
>extern u64 ioread64be(const void *);
>
>
>
>
>
>
>
>extern u64 ioread64_lo_hi(const void *addr);
>extern u64 ioread64_hi_lo(const void *addr);
>extern u64 ioread64be_lo_hi(const void *addr);
>extern u64 ioread64be_hi_lo(const void *addr);
>
>
>extern void iowrite8(u8, void *);
>extern void iowrite16(u16, void *);
>extern void iowrite16be(u16, void *);
>extern void iowrite32(u32, void *);
>extern void iowrite32be(u32, void *);
>
>extern void iowrite64(u64, void *);
>extern void iowrite64be(u64, void *);
>
>
>
>
>
>
>
>extern void iowrite64_lo_hi(u64 val, void *addr);
>extern void iowrite64_hi_lo(u64 val, void *addr);
>extern void iowrite64be_lo_hi(u64 val, void *addr);
>extern void iowrite64be_hi_lo(u64 val, void *addr);
># 82 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/iomap.h"
>extern void ioread8_rep(const void *port, void *buf, unsigned long count);
>extern void ioread16_rep(const void *port, void *buf, unsigned long count);
>extern void ioread32_rep(const void *port, void *buf, unsigned long count);
>
>extern void iowrite8_rep(void *port, const void *buf, unsigned long count);
>extern void iowrite16_rep(void *port, const void *buf, unsigned long count);
>extern void iowrite32_rep(void *port, const void *buf, unsigned long count);
>
>
>
>extern void *ioport_map(unsigned long port, unsigned int nr);
>extern void ioport_unmap(void *);
># 107 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/iomap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *ioremap_np(phys_addr_t offset, size_t size)
>{
> return ((void *)0);
>}
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/pci_iomap.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/pci_iomap.h"
>struct pci_dev;
>
>
>extern void *pci_iomap(struct pci_dev *dev, int bar, unsigned long max);
>extern void *pci_iomap_wc(struct pci_dev *dev, int bar, unsigned long max);
>extern void *pci_iomap_range(struct pci_dev *dev, int bar,
>         unsigned long offset,
>         unsigned long maxlen);
>extern void *pci_iomap_wc_range(struct pci_dev *dev, int bar,
>     unsigned long offset,
>     unsigned long maxlen);
>extern void pci_iounmap(struct pci_dev *dev, void *);
># 114 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/iomap.h" 2
># 227 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h" 2
># 240 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>extern void native_io_delay(void);
>
>extern int io_delay_type;
>extern void io_delay_init(void);
># 307 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outb_p(u8 value, u16 port) { __outb(value, port); slow_down_io(); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 inb_p(u16 port) { u8 value = __inb(port); slow_down_io(); return value; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outsb(u16 port, const void *addr, unsigned long count) { if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { u8 *value = (u8 *)addr; while (count) { __outb(*value, port); value++; count--; } } else { asm volatile("rep; outs" "b" : "+S"(addr), "+c"(count) : "d"(port) : "memory"); } } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insb(u16 port, void *addr, unsigned long count) { if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { u8 *value = (u8 *)addr; while (count) { *value = __inb(port); value++; count--; } } else { asm volatile("rep; ins" "b" : "+D"(addr), "+c"(count) : "d"(port) : "memory"); } }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outw_p(u16 value, u16 port) { __outw(value, port); slow_down_io(); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 inw_p(u16 port) { u16 value = __inw(port); slow_down_io(); return value; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outsw(u16 port, const void *addr, unsigned long count) { if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { u16 *value = (u16 *)addr; while (count) { __outw(*value, port); value++; count--; } } else { asm volatile("rep; outs" "w" : "+S"(addr), "+c"(count) : "d"(port) : "memory"); } } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insw(u16 port, void *addr, unsigned long count) { if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { u16 *value = (u16 *)addr; while (count) { *value = __inw(port); value++; count--; } } else { asm volatile("rep; ins" "w" : "+D"(addr), "+c"(count) : "d"(port) : "memory"); } }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outl_p(u32 value, u16 port) { __outl(value, port); slow_down_io(); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 inl_p(u16 port) { u32 value = __inl(port); slow_down_io(); return value; } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outsl(u16 port, const void *addr, unsigned long count) { if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { u32 *value = (u32 *)addr; while (count) { __outl(*value, port); value++; count--; } } else { asm volatile("rep; outs" "l" : "+S"(addr), "+c"(count) : "d"(port) : "memory"); } } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insl(u16 port, void *addr, unsigned long count) { if (cc_platform_has(CC_ATTR_GUEST_UNROLL_STRING_IO)) { u32 *value = (u32 *)addr; while (count) { *value = __inl(port); value++; count--; } } else { asm volatile("rep; ins" "l" : "+D"(addr), "+c"(count) : "d"(port) : "memory"); } }
># 326 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>extern void *xlate_dev_mem_ptr(phys_addr_t phys);
>extern void unxlate_dev_mem_ptr(phys_addr_t phys, void *addr);
>
>
>
>
>extern int ioremap_change_attr(unsigned long vaddr, unsigned long size,
>    enum page_cache_mode pcm);
>extern void *ioremap_wc(resource_size_t offset, unsigned long size);
>
>extern void *ioremap_wt(resource_size_t offset, unsigned long size);
>
>
>extern bool is_early_ioremap_ptep(pte_t *ptep);
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h"
># 1 "./arch/x86/include/generated/asm/mmiowb.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h" 2
># 317 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void readsb(const volatile void *addr, void *buffer,
>     unsigned int count)
>{
> if (count) {
>  u8 *buf = buffer;
>
>  do {
>   u8 x = __readb(addr);
>   *buf++ = x;
>  } while (--count);
> }
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void readsw(const volatile void *addr, void *buffer,
>     unsigned int count)
>{
> if (count) {
>  u16 *buf = buffer;
>
>  do {
>   u16 x = __readw(addr);
>   *buf++ = x;
>  } while (--count);
> }
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void readsl(const volatile void *addr, void *buffer,
>     unsigned int count)
>{
> if (count) {
>  u32 *buf = buffer;
>
>  do {
>   u32 x = __readl(addr);
>   *buf++ = x;
>  } while (--count);
> }
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void readsq(const volatile void *addr, void *buffer,
>     unsigned int count)
>{
> if (count) {
>  u64 *buf = buffer;
>
>  do {
>   u64 x = __readq(addr);
>   *buf++ = x;
>  } while (--count);
> }
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writesb(volatile void *addr, const void *buffer,
>      unsigned int count)
>{
> if (count) {
>  const u8 *buf = buffer;
>
>  do {
>   __writeb(*buf++, addr);
>  } while (--count);
> }
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writesw(volatile void *addr, const void *buffer,
>      unsigned int count)
>{
> if (count) {
>  const u16 *buf = buffer;
>
>  do {
>   __writew(*buf++, addr);
>  } while (--count);
> }
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writesl(volatile void *addr, const void *buffer,
>      unsigned int count)
>{
> if (count) {
>  const u32 *buf = buffer;
>
>  do {
>   __writel(*buf++, addr);
>  } while (--count);
> }
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void writesq(volatile void *addr, const void *buffer,
>      unsigned int count)
>{
> if (count) {
>  const u64 *buf = buffer;
>
>  do {
>   __writeq(*buf++, addr);
>  } while (--count);
> }
>}
># 526 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/logic_pio.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/logic_pio.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fwnode.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/fwnode.h"
>struct fwnode_operations;
>struct device;
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/fwnode.h"
>struct fwnode_handle {
> struct fwnode_handle *secondary;
> const struct fwnode_operations *ops;
> struct device *dev;
> struct list_head suppliers;
> struct list_head consumers;
> u8 flags;
>};
>
>struct fwnode_link {
> struct fwnode_handle *supplier;
> struct list_head s_hook;
> struct fwnode_handle *consumer;
> struct list_head c_hook;
>};
>
>
>
>
>
>
>
>struct fwnode_endpoint {
> unsigned int port;
> unsigned int id;
> const struct fwnode_handle *local_fwnode;
>};
># 79 "/usr/src/linux-5.14.21-150500.53/include/linux/fwnode.h"
>struct fwnode_reference_args {
> struct fwnode_handle *fwnode;
> unsigned int nargs;
> u64 args[8];
>};
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/fwnode.h"
>struct fwnode_operations {
> struct fwnode_handle *(*get)(struct fwnode_handle *fwnode);
> void (*put)(struct fwnode_handle *fwnode);
> bool (*device_is_available)(const struct fwnode_handle *fwnode);
> const void *(*device_get_match_data)(const struct fwnode_handle *fwnode,
>          const struct device *dev);
> bool (*device_dma_supported)(const struct fwnode_handle *fwnode);
> enum dev_dma_attr
> (*device_get_dma_attr)(const struct fwnode_handle *fwnode);
> bool (*property_present)(const struct fwnode_handle *fwnode,
>     const char *propname);
> int (*property_read_int_array)(const struct fwnode_handle *fwnode,
>           const char *propname,
>           unsigned int elem_size, void *val,
>           size_t nval);
> int
> (*property_read_string_array)(const struct fwnode_handle *fwnode_handle,
>          const char *propname, const char **val,
>          size_t nval);
> const char *(*get_name)(const struct fwnode_handle *fwnode);
> const char *(*get_name_prefix)(const struct fwnode_handle *fwnode);
> struct fwnode_handle *(*get_parent)(const struct fwnode_handle *fwnode);
> struct fwnode_handle *
> (*get_next_child_node)(const struct fwnode_handle *fwnode,
>          struct fwnode_handle *child);
> struct fwnode_handle *
> (*get_named_child_node)(const struct fwnode_handle *fwnode,
>    const char *name);
> int (*get_reference_args)(const struct fwnode_handle *fwnode,
>      const char *prop, const char *nargs_prop,
>      unsigned int nargs, unsigned int index,
>      struct fwnode_reference_args *args);
> struct fwnode_handle *
> (*graph_get_next_endpoint)(const struct fwnode_handle *fwnode,
>       struct fwnode_handle *prev);
> struct fwnode_handle *
> (*graph_get_remote_endpoint)(const struct fwnode_handle *fwnode);
> struct fwnode_handle *
> (*graph_get_port_parent)(struct fwnode_handle *fwnode);
> int (*graph_parse_endpoint)(const struct fwnode_handle *fwnode,
>        struct fwnode_endpoint *endpoint);
> int (*irq_get)(const struct fwnode_handle *fwnode, unsigned int index);
> int (*add_links)(struct fwnode_handle *fwnode);
>};
># 176 "/usr/src/linux-5.14.21-150500.53/include/linux/fwnode.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fwnode_init(struct fwnode_handle *fwnode,
>          const struct fwnode_operations *ops)
>{
> fwnode->ops = ops;
> INIT_LIST_HEAD(&fwnode->consumers);
> INIT_LIST_HEAD(&fwnode->suppliers);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fwnode_dev_initialized(struct fwnode_handle *fwnode,
>       bool initialized)
>{
> if (IS_ERR_OR_NULL(fwnode))
>  return;
>
> if (initialized)
>  fwnode->flags |= ((((1UL))) << (2));
> else
>  fwnode->flags &= ~((((1UL))) << (2));
>}
>
>extern u32 fw_devlink_get_flags(void);
>extern bool fw_devlink_is_strict(void);
>int fwnode_link_add(struct fwnode_handle *con, struct fwnode_handle *sup);
>void fwnode_links_purge(struct fwnode_handle *fwnode);
>void fw_devlink_purge_absent_suppliers(struct fwnode_handle *fwnode);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/logic_pio.h" 2
>
>enum {
> LOGIC_PIO_INDIRECT,
> LOGIC_PIO_CPU_MMIO,
>};
>
>struct logic_pio_hwaddr {
> struct list_head list;
> struct fwnode_handle *fwnode;
> resource_size_t hw_start;
> resource_size_t io_start;
> resource_size_t size;
> unsigned long flags;
>
> void *hostdata;
> const struct logic_pio_host_ops *ops;
>};
>
>struct logic_pio_host_ops {
> u32 (*in)(void *hostdata, unsigned long addr, size_t dwidth);
> void (*out)(void *hostdata, unsigned long addr, u32 val,
>      size_t dwidth);
> u32 (*ins)(void *hostdata, unsigned long addr, void *buffer,
>     size_t dwidth, unsigned int count);
> void (*outs)(void *hostdata, unsigned long addr, const void *buffer,
>       size_t dwidth, unsigned int count);
>};
># 116 "/usr/src/linux-5.14.21-150500.53/include/linux/logic_pio.h"
>struct logic_pio_hwaddr *find_io_range_by_fwnode(struct fwnode_handle *fwnode);
>unsigned long logic_pio_trans_hwaddr(struct fwnode_handle *fwnode,
>   resource_size_t hw_addr, resource_size_t size);
>int logic_pio_register_range(struct logic_pio_hwaddr *newrange);
>void logic_pio_unregister_range(struct logic_pio_hwaddr *range);
>resource_size_t logic_pio_to_hwaddr(unsigned long pio);
>unsigned long logic_pio_trans_cpuaddr(resource_size_t hw_addr);
># 527 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h" 2
># 658 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insb_p(unsigned long addr, void *buffer, unsigned int count)
>{
> insb(addr, buffer, count);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insw_p(unsigned long addr, void *buffer, unsigned int count)
>{
> insw(addr, buffer, count);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insl_p(unsigned long addr, void *buffer, unsigned int count)
>{
> insl(addr, buffer, count);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outsb_p(unsigned long addr, const void *buffer,
>      unsigned int count)
>{
> outsb(addr, buffer, count);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outsw_p(unsigned long addr, const void *buffer,
>      unsigned int count)
>{
> outsw(addr, buffer, count);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void outsl_p(unsigned long addr, const void *buffer,
>      unsigned int count)
>{
> outsl(addr, buffer, count);
>}
># 1036 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h"
>extern void *ioport_map(unsigned long port, unsigned int nr);
>extern void ioport_unmap(void *p);
># 1128 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/io.h"
>extern int devmem_is_allowed(unsigned long pfn);
># 344 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h" 2
>
>
>
>extern int __attribute__((__warn_unused_result__)) arch_phys_wc_index(int handle);
>
>
>extern int __attribute__((__warn_unused_result__)) arch_phys_wc_add(unsigned long base,
>      unsigned long size);
>extern void arch_phys_wc_del(int handle);
>
>
>
>
>extern int arch_io_reserve_memtype_wc(resource_size_t start, resource_size_t size);
>extern void arch_io_free_memtype_wc(resource_size_t start, resource_size_t size);
>
>
>
>
>extern bool arch_memremap_can_ram_remap(resource_size_t offset,
>     unsigned long size,
>     unsigned long flags);
>
>
>extern bool phys_mem_access_encrypted(unsigned long phys_addr,
>          unsigned long size);
># 391 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void iosubmit_cmds512(void *dst, const void *src,
>        size_t count)
>{
> const u8 *from = src;
> const u8 *end = from + count * 64;
>
> while (from < end) {
>  movdir64b(dst, from);
>  from += 64;
> }
>}
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h" 2
>
>
>struct device;
>struct resource;
>
>__attribute__((__externally_visible__)) void __iowrite32_copy(void *to, const void *from, size_t count);
>void __ioread32_copy(void *to, const void *from, size_t count);
>void __iowrite64_copy(void *to, const void *from, size_t count);
>
>
>int ioremap_page_range(unsigned long addr, unsigned long end,
>         phys_addr_t phys_addr, pgprot_t prot);
># 38 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h"
>void * devm_ioport_map(struct device *dev, unsigned long port,
>          unsigned int nr);
>void devm_ioport_unmap(struct device *dev, void *addr);
># 56 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h"
>void *devm_ioremap(struct device *dev, resource_size_t offset,
>      resource_size_t size);
>void *devm_ioremap_uc(struct device *dev, resource_size_t offset,
>       resource_size_t size);
>void *devm_ioremap_wc(struct device *dev, resource_size_t offset,
>       resource_size_t size);
>void *devm_ioremap_np(struct device *dev, resource_size_t offset,
>       resource_size_t size);
>void devm_iounmap(struct device *dev, void *addr);
>int check_signature(const volatile void *io_addr,
>   const unsigned char *signature, int length);
>void devm_ioremap_release(struct device *dev, void *res);
>
>void *devm_memremap(struct device *dev, resource_size_t offset,
>  size_t size, unsigned long flags);
>void devm_memunmap(struct device *dev, void *addr);
># 86 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *pci_remap_cfgspace(phys_addr_t offset,
>            size_t size)
>{
> return ioremap_np(offset, size) ?: ioremap(offset, size);
>}
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h"
>int devm_arch_phys_wc_add(struct device *dev, unsigned long base, unsigned long size);
>
>enum {
>
> MEMREMAP_WB = 1 << 0,
> MEMREMAP_WT = 1 << 1,
> MEMREMAP_WC = 1 << 2,
> MEMREMAP_ENC = 1 << 3,
> MEMREMAP_DEC = 1 << 4,
>};
>
>void *memremap(resource_size_t offset, size_t size, unsigned long flags);
>void memunmap(void *addr);
># 171 "/usr/src/linux-5.14.21-150500.53/include/linux/io.h"
>int devm_arch_io_reserve_memtype_wc(struct device *dev, resource_size_t start,
>        resource_size_t size);
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/resource_ext.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/resource_ext.h"
>struct resource_win {
> struct resource res;
> resource_size_t offset;
>};
>
>
>
>
>
>struct resource_entry {
> struct list_head node;
> struct resource *res;
> resource_size_t offset;
> struct resource __res;
>};
>
>extern struct resource_entry *
>resource_list_create_entry(struct resource *res, size_t extra_size);
>extern void resource_list_free(struct list_head *head);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void resource_list_add(struct resource_entry *entry,
>         struct list_head *head)
>{
> list_add(&entry->node, head);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void resource_list_add_tail(struct resource_entry *entry,
>       struct list_head *head)
>{
> list_add_tail(&entry->node, head);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void resource_list_del(struct resource_entry *entry)
>{
> list_del(&entry->node);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void resource_list_free_entry(struct resource_entry *entry)
>{
> kfree(entry);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>resource_list_destroy_entry(struct resource_entry *entry)
>{
> resource_list_del(entry);
> resource_list_free_entry(entry);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct resource_entry *
>resource_list_first_type(struct list_head *list, unsigned long type)
>{
> struct resource_entry *entry;
>
> for ((entry) = ({ void *__mptr = (void *)(((list))->next); do { extern void __compiletime_assert_281(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(((list))->next)), typeof(((typeof(*(entry)) *)0)->node)) && !__builtin_types_compatible_p(typeof(*(((list))->next)), typeof(void))))) __compiletime_assert_281(); } while (0); ((typeof(*(entry)) *)(__mptr - __builtin_offsetof(typeof(*(entry)), node))); }); !(&(entry)->node == ((list))); (entry) = ({ void *__mptr = (void *)(((entry))->node.next); do { extern void __compiletime_assert_282(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(((entry))->node.next)), typeof(((typeof(*((entry))) *)0)->node)) && !__builtin_types_compatible_p(typeof(*(((entry))->node.next)), typeof(void))))) __compiletime_assert_282(); } while (0); ((typeof(*((entry))) *)(__mptr - __builtin_offsetof(typeof(*((entry))), node))); })) {
>  if (resource_type(entry->res) == type)
>   return entry;
> }
> return ((void *)0);
>}
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/pci.h" 1
># 21 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/pci.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/pci_regs.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/pci.h" 2
># 42 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pci_ids.h" 1
># 44 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 75 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct pci_slot {
> struct pci_bus *bus;
> struct list_head list;
> struct hotplug_slot *hotplug;
> unsigned char number;
> struct kobject kobj;
>
> void* suse_kabi_padding;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *pci_slot_name(const struct pci_slot *slot)
>{
> return kobject_name(&slot->kobj);
>}
>
>
>enum pci_mmap_state {
> pci_mmap_io,
> pci_mmap_mem
>};
>
>
>enum {
>
> PCI_STD_RESOURCES,
> PCI_STD_RESOURCE_END = PCI_STD_RESOURCES + 6 - 1,
>
>
> PCI_ROM_RESOURCE,
>
>
>
> PCI_IOV_RESOURCES,
> PCI_IOV_RESOURCE_END = PCI_IOV_RESOURCES + 6 - 1,
># 126 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
> PCI_BRIDGE_RESOURCES,
> PCI_BRIDGE_RESOURCE_END = PCI_BRIDGE_RESOURCES +
>      4 - 1,
>
>
> PCI_NUM_RESOURCES,
>
>
> DEVICE_COUNT_RESOURCE = PCI_NUM_RESOURCES,
>};
># 148 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>enum pci_interrupt_pin {
> PCI_INTERRUPT_UNKNOWN,
> PCI_INTERRUPT_INTA,
> PCI_INTERRUPT_INTB,
> PCI_INTERRUPT_INTC,
> PCI_INTERRUPT_INTD,
>};
># 163 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>typedef int pci_power_t;
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>extern const char *pci_power_names[];
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *pci_power_name(pci_power_t state)
>{
> return pci_power_names[1 + ( int) state];
>}
># 188 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>typedef unsigned int pci_channel_state_t;
>
>enum {
>
> pci_channel_io_normal = ( pci_channel_state_t) 1,
>
>
> pci_channel_io_frozen = ( pci_channel_state_t) 2,
>
>
> pci_channel_io_perm_failure = ( pci_channel_state_t) 3,
>};
>
>typedef unsigned int pcie_reset_state_t;
>
>enum pcie_reset_state {
>
> pcie_deassert_reset = ( pcie_reset_state_t) 1,
>
>
> pcie_warm_reset = ( pcie_reset_state_t) 2,
>
>
> pcie_hot_reset = ( pcie_reset_state_t) 3
>};
>
>typedef unsigned short pci_dev_flags_t;
>enum pci_dev_flags {
>
> PCI_DEV_FLAGS_MSI_INTX_DISABLE_BUG = ( pci_dev_flags_t) (1 << 0),
>
> PCI_DEV_FLAGS_NO_D3 = ( pci_dev_flags_t) (1 << 1),
>
> PCI_DEV_FLAGS_ASSIGNED = ( pci_dev_flags_t) (1 << 2),
>
> PCI_DEV_FLAGS_ACS_ENABLED_QUIRK = ( pci_dev_flags_t) (1 << 3),
>
> PCI_DEV_FLAG_PCIE_BRIDGE_ALIAS = ( pci_dev_flags_t) (1 << 5),
>
> PCI_DEV_FLAGS_NO_BUS_RESET = ( pci_dev_flags_t) (1 << 6),
>
> PCI_DEV_FLAGS_NO_PM_RESET = ( pci_dev_flags_t) (1 << 7),
>
> PCI_DEV_FLAGS_VPD_REF_F0 = ( pci_dev_flags_t) (1 << 8),
>
> PCI_DEV_FLAGS_BRIDGE_XLATE_ROOT = ( pci_dev_flags_t) (1 << 9),
>
> PCI_DEV_FLAGS_NO_FLR_RESET = ( pci_dev_flags_t) (1 << 10),
>
> PCI_DEV_FLAGS_NO_RELAXED_ORDERING = ( pci_dev_flags_t) (1 << 11),
>
> PCI_DEV_FLAGS_HAS_MSI_MASKING = ( pci_dev_flags_t) (1 << 12),
>};
>
>enum pci_irq_reroute_variant {
> INTEL_IRQ_REROUTE_VARIANT = 1,
> MAX_IRQ_REROUTE_VARIANTS = 3
>};
>
>typedef unsigned short pci_bus_flags_t;
>enum pci_bus_flags {
> PCI_BUS_FLAGS_NO_MSI = ( pci_bus_flags_t) 1,
> PCI_BUS_FLAGS_NO_MMRBC = ( pci_bus_flags_t) 2,
> PCI_BUS_FLAGS_NO_AERSID = ( pci_bus_flags_t) 4,
> PCI_BUS_FLAGS_NO_EXTCFG = ( pci_bus_flags_t) 8,
>};
>
>
>enum pcie_link_width {
> PCIE_LNK_WIDTH_RESRV = 0x00,
> PCIE_LNK_X1 = 0x01,
> PCIE_LNK_X2 = 0x02,
> PCIE_LNK_X4 = 0x04,
> PCIE_LNK_X8 = 0x08,
> PCIE_LNK_X12 = 0x0c,
> PCIE_LNK_X16 = 0x10,
> PCIE_LNK_X32 = 0x20,
> PCIE_LNK_WIDTH_UNKNOWN = 0xff,
>};
>
>
>enum pci_bus_speed {
> PCI_SPEED_33MHz = 0x00,
> PCI_SPEED_66MHz = 0x01,
> PCI_SPEED_66MHz_PCIX = 0x02,
> PCI_SPEED_100MHz_PCIX = 0x03,
> PCI_SPEED_133MHz_PCIX = 0x04,
> PCI_SPEED_66MHz_PCIX_ECC = 0x05,
> PCI_SPEED_100MHz_PCIX_ECC = 0x06,
> PCI_SPEED_133MHz_PCIX_ECC = 0x07,
> PCI_SPEED_66MHz_PCIX_266 = 0x09,
> PCI_SPEED_100MHz_PCIX_266 = 0x0a,
> PCI_SPEED_133MHz_PCIX_266 = 0x0b,
> AGP_UNKNOWN = 0x0c,
> AGP_1X = 0x0d,
> AGP_2X = 0x0e,
> AGP_4X = 0x0f,
> AGP_8X = 0x10,
> PCI_SPEED_66MHz_PCIX_533 = 0x11,
> PCI_SPEED_100MHz_PCIX_533 = 0x12,
> PCI_SPEED_133MHz_PCIX_533 = 0x13,
> PCIE_SPEED_2_5GT = 0x14,
> PCIE_SPEED_5_0GT = 0x15,
> PCIE_SPEED_8_0GT = 0x16,
> PCIE_SPEED_16_0GT = 0x17,
> PCIE_SPEED_32_0GT = 0x18,
> PCIE_SPEED_64_0GT = 0x19,
> PCI_SPEED_UNKNOWN = 0xff,
>};
>
>enum pci_bus_speed pcie_get_speed_cap(struct pci_dev *dev);
>enum pcie_link_width pcie_get_width_cap(struct pci_dev *dev);
>
>struct pci_vpd {
> struct mutex lock;
> unsigned int len;
> u8 cap;
>};
>
>struct irq_affinity;
>struct pcie_link_state;
>struct pci_sriov;
>struct pci_p2pdma;
>struct rcec_ea;
>
>
>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;
> unsigned short vendor;
> unsigned short device;
> unsigned short subsystem_vendor;
> unsigned short subsystem_device;
> unsigned int class;
> u8 revision;
> u8 hdr_type;
>
> u16 aer_cap;
> struct aer_stats *aer_stats;
>
>
> struct rcec_ea *rcec_ea;
> struct pci_dev *rcec;
>
> u32 devcap;
> u8 pcie_cap;
> u8 msi_cap;
> u8 msix_cap;
> u8 pcie_mpss:3;
> u8 rom_base_reg;
> u8 pin;
> u16 pcie_flags_reg;
> unsigned long *dma_alias_mask;
>
> struct pci_driver *driver;
> u64 dma_mask;
>
>
>
>
>
> struct device_dma_parameters dma_parms;
>
> pci_power_t current_state;
>
>
> unsigned int imm_ready:1;
> u8 pm_cap;
> unsigned int pme_support:5;
>
> 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 bridge_d3:1;
> unsigned int d3cold_allowed:1;
> unsigned int mmio_always_on:1;
>
> unsigned int wakeup_prepared:1;
> unsigned int runtime_d3cold:1;
>
>
>
> unsigned int skip_bus_pm:1;
> unsigned int ignore_hotplug:1;
> unsigned int hotplug_user_indicators:1;
>
>
> unsigned int clear_retrain_link:1;
>
> unsigned int d3hot_delay;
> unsigned int d3cold_delay;
>
>
> struct pcie_link_state *link_state;
> unsigned int ltr_path:1;
>
> u16 l1ss;
>
> unsigned int pasid_no_tlp:1;
> unsigned int eetlp_prefix_path:1;
>
> pci_channel_state_t error_state;
> struct device dev;
>
> int cfg_size;
>
>
>
>
>
> unsigned int irq;
> struct resource resource[DEVICE_COUNT_RESOURCE];
>
> bool match_driver;
>
> unsigned int transparent:1;
> unsigned int io_window:1;
> unsigned int pref_window:1;
> unsigned int pref_64_window:1;
> unsigned int multifunction:1;
>
> unsigned int is_busmaster:1;
> unsigned int no_msi:1;
> unsigned int no_64bit_msi:1;
> unsigned int block_cfg_access:1;
> unsigned int broken_parity_status:1;
> unsigned int irq_reroute_variant:2;
> unsigned int msi_enabled:1;
> unsigned int msix_enabled:1;
> unsigned int ari_enabled:1;
> unsigned int ats_enabled:1;
> unsigned int pasid_enabled:1;
> unsigned int pri_enabled:1;
> unsigned int 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 is_hotplug_bridge:1;
> unsigned int shpc_managed:1;
> unsigned int is_thunderbolt:1;
>
>
>
>
>
>
>
> unsigned int untrusted:1;
>
>
>
>
>
> unsigned int external_facing:1;
> unsigned int broken_intx_masking:1;
> unsigned int io_window_1k:1;
> unsigned int irq_managed:1;
> unsigned int non_compliant_bars:1;
> unsigned int is_probed:1;
> unsigned int link_active_reporting:1;
> unsigned int no_vf_scan:1;
> unsigned int no_command_memory:1;
> unsigned int rom_bar_overlap:1;
> pci_dev_flags_t dev_flags;
> atomic_t enable_cnt;
>
> u32 saved_config_space[16];
> struct hlist_head saved_cap_space;
> int rom_attr_enabled;
> struct bin_attribute *res_attr[DEVICE_COUNT_RESOURCE];
> struct bin_attribute *res_attr_wc[DEVICE_COUNT_RESOURCE];
>
>
> unsigned int broken_cmd_compl:1;
>
>
> unsigned int ptm_root:1;
> unsigned int ptm_enabled:1;
> u8 ptm_granularity;
>
>
> const struct attribute_group **msi_irq_groups;
>
> struct pci_vpd vpd;
>
> u16 dpc_cap;
> unsigned int dpc_rp_extensions:1;
> u8 dpc_rp_log_size;
>
>
> union {
>  struct pci_sriov *sriov;
>  struct pci_dev *physfn;
> };
> u16 ats_cap;
> u8 ats_stu;
>
>
> u16 pri_cap;
> u32 pri_reqs_alloc;
> unsigned int pasid_required:1;
>
>
> u16 pasid_cap;
> u16 pasid_features;
>
>
> struct pci_p2pdma *p2pdma;
>
> u16 acs_cap;
> phys_addr_t rom;
> size_t romlen;
> char *driver_override;
>
> void* suse_kabi_padding;
>
> unsigned long priv_flags;
>
>
> u8 reset_methods[7];
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pci_dev *pci_physfn(struct pci_dev *dev)
>{
>
> if (dev->is_virtfn)
>  dev = dev->physfn;
>
> return dev;
>}
>
>struct pci_dev *pci_alloc_dev(struct pci_bus *bus);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_channel_offline(struct pci_dev *pdev)
>{
> return (pdev->error_state != pci_channel_io_normal);
>}
># 549 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct pci_host_bridge {
> struct device dev;
> struct pci_bus *bus;
> struct pci_ops *ops;
> struct pci_ops *child_ops;
> void *sysdata;
> int busnr;
> int domain_nr;
> struct list_head windows;
> struct list_head dma_ranges;
> u8 (*swizzle_irq)(struct pci_dev *, u8 *);
> int (*map_irq)(const struct pci_dev *, u8, u8);
> void (*release_fn)(struct pci_host_bridge *);
> void *release_data;
> unsigned int ignore_reset_delay:1;
> unsigned int no_ext_tags:1;
> unsigned int native_aer:1;
> unsigned int native_pcie_hotplug:1;
> unsigned int native_shpc_hotplug:1;
> unsigned int native_pme:1;
> unsigned int native_ltr:1;
> unsigned int native_dpc:1;
> unsigned int preserve_config:1;
> unsigned int size_windows:1;
> unsigned int msi_domain:1;
>
> void* suse_kabi_padding;
>
>
> resource_size_t (*align_resource)(struct pci_dev *dev,
>   const struct resource *res,
>   resource_size_t start,
>   resource_size_t size,
>   resource_size_t align);
> unsigned long private[] __attribute__((__aligned__((1 << (6)))));
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *pci_host_bridge_priv(struct pci_host_bridge *bridge)
>{
> return (void *)bridge->private;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pci_host_bridge *pci_host_bridge_from_priv(void *priv)
>{
> return ({ void *__mptr = (void *)(priv); do { extern void __compiletime_assert_283(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(priv)), typeof(((struct pci_host_bridge *)0)->private)) && !__builtin_types_compatible_p(typeof(*(priv)), typeof(void))))) __compiletime_assert_283(); } while (0); ((struct pci_host_bridge *)(__mptr - __builtin_offsetof(struct pci_host_bridge, private))); });
>}
>
>struct pci_host_bridge *pci_alloc_host_bridge(size_t priv);
>struct pci_host_bridge *devm_pci_alloc_host_bridge(struct device *dev,
>         size_t priv);
>void pci_free_host_bridge(struct pci_host_bridge *bridge);
>struct pci_host_bridge *pci_find_host_bridge(struct pci_bus *bus);
>
>void pci_set_host_bridge_release(struct pci_host_bridge *bridge,
>     void (*release_fn)(struct pci_host_bridge *),
>     void *release_data);
>
>int pcibios_root_bridge_prepare(struct pci_host_bridge *bridge);
># 625 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct pci_bus_resource {
> struct list_head list;
> struct resource *res;
> unsigned int flags;
>};
>
>
>
>struct pci_bus {
> struct list_head node;
> struct pci_bus *parent;
> struct list_head children;
> struct list_head devices;
> struct pci_dev *self;
> struct list_head slots;
>
> struct resource *resource[4];
> struct list_head resources;
> struct resource busn_res;
>
> struct pci_ops *ops;
> void *sysdata;
> struct proc_dir_entry *procdir;
>
> unsigned char number;
> unsigned char primary;
> unsigned char max_bus_speed;
> unsigned char cur_bus_speed;
>
>
>
>
> char name[48];
>
> unsigned short bridge_ctl;
> pci_bus_flags_t bus_flags;
> struct device *bridge;
> struct device dev;
> struct bin_attribute *legacy_io;
> struct bin_attribute *legacy_mem;
> unsigned int is_added:1;
>
> void* suse_kabi_padding;
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 pci_dev_id(struct pci_dev *dev)
>{
> return ((((u16)(dev->bus->number)) << 8) | (dev->devfn));
>}
># 685 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_is_root_bus(struct pci_bus *pbus)
>{
> return !(pbus->parent);
>}
># 697 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_is_bridge(struct pci_dev *dev)
>{
> return dev->hdr_type == 1 ||
>  dev->hdr_type == 2;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pci_dev *pci_upstream_bridge(struct pci_dev *dev)
>{
> dev = pci_physfn(dev);
> if (pci_is_root_bus(dev->bus))
>  return ((void *)0);
>
> return dev->bus->self;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_dev_msi_enabled(struct pci_dev *pci_dev)
>{
> return pci_dev->msi_enabled || pci_dev->msix_enabled;
>}
># 735 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pcibios_err_to_errno(int err)
>{
> if (err <= 0x00)
>  return err;
>
> switch (err) {
> case 0x81:
>  return -2;
> case 0x83:
>  return -25;
> case 0x86:
>  return -19;
> case 0x87:
>  return -14;
> case 0x88:
>  return -5;
> case 0x89:
>  return -28;
> }
>
> return -34;
>}
>
>
>
>struct pci_ops {
> int (*add_bus)(struct pci_bus *bus);
> void (*remove_bus)(struct pci_bus *bus);
> void *(*map_bus)(struct pci_bus *bus, unsigned int devfn, int where);
> int (*read)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 *val);
> int (*write)(struct pci_bus *bus, unsigned int devfn, int where, int size, u32 val);
>
> void *suse_kabi_padding;
>};
>
>
>
>
>
>int raw_pci_read(unsigned int domain, unsigned int bus, unsigned int devfn,
>   int reg, int len, u32 *val);
>int raw_pci_write(unsigned int domain, unsigned int bus, unsigned int devfn,
>    int reg, int len, u32 val);
>
>
>typedef u64 pci_bus_addr_t;
>
>
>
>
>struct pci_bus_region {
> pci_bus_addr_t start;
> pci_bus_addr_t end;
>};
>
>struct pci_dynids {
> spinlock_t lock;
> struct list_head list;
>};
># 803 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>typedef unsigned int pci_ers_result_t;
>
>enum pci_ers_result {
>
> PCI_ERS_RESULT_NONE = ( pci_ers_result_t) 1,
>
>
> PCI_ERS_RESULT_CAN_RECOVER = ( pci_ers_result_t) 2,
>
>
> PCI_ERS_RESULT_NEED_RESET = ( pci_ers_result_t) 3,
>
>
> PCI_ERS_RESULT_DISCONNECT = ( pci_ers_result_t) 4,
>
>
> PCI_ERS_RESULT_RECOVERED = ( pci_ers_result_t) 5,
>
>
> PCI_ERS_RESULT_NO_AER_DRIVER = ( pci_ers_result_t) 6,
>};
>
>
>struct pci_error_handlers {
>
> pci_ers_result_t (*error_detected)(struct pci_dev *dev,
>        pci_channel_state_t error);
>
>
> pci_ers_result_t (*mmio_enabled)(struct pci_dev *dev);
>
>
> pci_ers_result_t (*slot_reset)(struct pci_dev *dev);
>
>
> void (*reset_prepare)(struct pci_dev *dev);
> void (*reset_done)(struct pci_dev *dev);
>
>
> void (*resume)(struct pci_dev *dev);
>
> void *suse_kabi_padding;
>};
>
>
>struct module;
># 906 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct pci_driver {
> struct list_head node;
> const char *name;
> const struct pci_device_id *id_table;
> int (*probe)(struct pci_dev *dev, const struct pci_device_id *id);
> void (*remove)(struct pci_dev *dev);
> int (*suspend)(struct pci_dev *dev, pm_message_t state);
> int (*resume)(struct pci_dev *dev);
> void (*shutdown)(struct pci_dev *dev);
> int (*sriov_configure)(struct pci_dev *dev, int num_vfs);
> int (*sriov_set_msix_vec_count)(struct pci_dev *vf, int msix_vec_count);
> u32 (*sriov_get_vf_total_msix)(struct pci_dev *pf);
> const struct pci_error_handlers *err_handler;
> const struct attribute_group **groups;
> const struct attribute_group **dev_groups;
>
> void* suse_kabi_padding;
>
> struct device_driver driver;
> struct pci_dynids dynids;
> bool driver_managed_dma;
>};
># 1030 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>enum {
> PCI_REASSIGN_ALL_RSRC = 0x00000001,
> PCI_REASSIGN_ALL_BUS = 0x00000002,
> PCI_PROBE_ONLY = 0x00000004,
> PCI_CAN_SKIP_ISA_ALIGN = 0x00000008,
> PCI_ENABLE_PROC_DOMAINS = 0x00000010,
> PCI_COMPAT_DOMAIN_0 = 0x00000020,
> PCI_SCAN_ALL_PCIE_DEVS = 0x00000040,
>};
># 1048 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>extern unsigned int pci_flags;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pci_set_flags(int flags) { pci_flags = flags; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pci_add_flags(int flags) { pci_flags |= flags; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pci_clear_flags(int flags) { pci_flags &= ~flags; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_has_flag(int flag) { return pci_flags & flag; }
>
>void pcie_bus_configure_settings(struct pci_bus *bus);
>
>enum pcie_bus_config_types {
> PCIE_BUS_TUNE_OFF,
> PCIE_BUS_DEFAULT,
> PCIE_BUS_SAFE,
> PCIE_BUS_PERFORMANCE,
> PCIE_BUS_PEER2PEER,
>};
>
>extern enum pcie_bus_config_types pcie_bus_config;
>
>extern struct bus_type pci_bus_type;
>
>
>
>extern struct list_head pci_root_buses;
>
>int no_pci_devices(void);
>
>void pcibios_resource_survey_bus(struct pci_bus *bus);
>void pcibios_bus_add_device(struct pci_dev *pdev);
>void pcibios_add_bus(struct pci_bus *bus);
>void pcibios_remove_bus(struct pci_bus *bus);
>void pcibios_fixup_bus(struct pci_bus *);
>int __attribute__((__warn_unused_result__)) pcibios_enable_device(struct pci_dev *, int mask);
>
>char *pcibios_setup(char *str);
>
>
>resource_size_t pcibios_align_resource(void *, const struct resource *,
>    resource_size_t,
>    resource_size_t);
>
>
>void pci_fixup_cardbus(struct pci_bus *);
>
>
>
>void pcibios_resource_to_bus(struct pci_bus *bus, struct pci_bus_region *region,
>        struct resource *res);
>void pcibios_bus_to_resource(struct pci_bus *bus, struct resource *res,
>        struct pci_bus_region *region);
>void pcibios_scan_specific_bus(int busn);
>struct pci_bus *pci_find_bus(int domain, int busnr);
>void pci_bus_add_devices(const struct pci_bus *bus);
>struct pci_bus *pci_scan_bus(int bus, struct pci_ops *ops, void *sysdata);
>struct pci_bus *pci_create_root_bus(struct device *parent, int bus,
>        struct pci_ops *ops, void *sysdata,
>        struct list_head *resources);
>int pci_host_probe(struct pci_host_bridge *bridge);
>int pci_bus_insert_busn_res(struct pci_bus *b, int bus, int busmax);
>int pci_bus_update_busn_res_end(struct pci_bus *b, int busmax);
>void pci_bus_release_busn_res(struct pci_bus *b);
>struct pci_bus *pci_scan_root_bus(struct device *parent, int bus,
>      struct pci_ops *ops, void *sysdata,
>      struct list_head *resources);
>int pci_scan_root_bus_bridge(struct pci_host_bridge *bridge);
>struct pci_bus *pci_add_new_bus(struct pci_bus *parent, struct pci_dev *dev,
>    int busnr);
>struct pci_slot *pci_create_slot(struct pci_bus *parent, int slot_nr,
>     const char *name,
>     struct hotplug_slot *hotplug);
>void pci_destroy_slot(struct pci_slot *slot);
>
>void pci_dev_assign_slot(struct pci_dev *dev);
>
>
>
>int pci_scan_slot(struct pci_bus *bus, int devfn);
>struct pci_dev *pci_scan_single_device(struct pci_bus *bus, int devfn);
>void pci_device_add(struct pci_dev *dev, struct pci_bus *bus);
>unsigned int pci_scan_child_bus(struct pci_bus *bus);
>void pci_bus_add_device(struct pci_dev *dev);
>void pci_read_bridge_bases(struct pci_bus *child);
>struct resource *pci_find_parent_resource(const struct pci_dev *dev,
>       struct resource *res);
>u8 pci_swizzle_interrupt_pin(const struct pci_dev *dev, u8 pin);
>int pci_get_interrupt_pin(struct pci_dev *dev, struct pci_dev **bridge);
>u8 pci_common_swizzle(struct pci_dev *dev, u8 *pinp);
>struct pci_dev *pci_dev_get(struct pci_dev *dev);
>void pci_dev_put(struct pci_dev *dev);
>void pci_remove_bus(struct pci_bus *b);
>void pci_stop_and_remove_bus_device(struct pci_dev *dev);
>void pci_stop_and_remove_bus_device_locked(struct pci_dev *dev);
>void pci_stop_root_bus(struct pci_bus *bus);
>void pci_remove_root_bus(struct pci_bus *bus);
>void pci_setup_cardbus(struct pci_bus *bus);
>void pcibios_setup_bridge(struct pci_bus *bus, unsigned long type);
>void pci_sort_breadthfirst(void);
>
>
>
>
>
>u8 pci_bus_find_capability(struct pci_bus *bus, unsigned int devfn, int cap);
>u8 pci_find_capability(struct pci_dev *dev, int cap);
>u8 pci_find_next_capability(struct pci_dev *dev, u8 pos, int cap);
>u8 pci_find_ht_capability(struct pci_dev *dev, int ht_cap);
>u8 pci_find_next_ht_capability(struct pci_dev *dev, u8 pos, int ht_cap);
>u16 pci_find_ext_capability(struct pci_dev *dev, int cap);
>u16 pci_find_next_ext_capability(struct pci_dev *dev, u16 pos, int cap);
>struct pci_bus *pci_find_next_bus(const struct pci_bus *from);
>u16 pci_find_vsec_capability(struct pci_dev *dev, u16 vendor, int cap);
>
>u64 pci_get_dsn(struct pci_dev *dev);
>
>struct pci_dev *pci_get_device(unsigned int vendor, unsigned int device,
>          struct pci_dev *from);
>struct pci_dev *pci_get_subsys(unsigned int vendor, unsigned int device,
>          unsigned int ss_vendor, unsigned int ss_device,
>          struct pci_dev *from);
>struct pci_dev *pci_get_slot(struct pci_bus *bus, unsigned int devfn);
>struct pci_dev *pci_get_domain_bus_and_slot(int domain, unsigned int bus,
>         unsigned int devfn);
>struct pci_dev *pci_get_class(unsigned int class, struct pci_dev *from);
>int pci_dev_present(const struct pci_device_id *ids);
>
>int pci_bus_read_config_byte(struct pci_bus *bus, unsigned int devfn,
>        int where, u8 *val);
>int pci_bus_read_config_word(struct pci_bus *bus, unsigned int devfn,
>        int where, u16 *val);
>int pci_bus_read_config_dword(struct pci_bus *bus, unsigned int devfn,
>         int where, u32 *val);
>int pci_bus_write_config_byte(struct pci_bus *bus, unsigned int devfn,
>         int where, u8 val);
>int pci_bus_write_config_word(struct pci_bus *bus, unsigned int devfn,
>         int where, u16 val);
>int pci_bus_write_config_dword(struct pci_bus *bus, unsigned int devfn,
>          int where, u32 val);
>
>int pci_generic_config_read(struct pci_bus *bus, unsigned int devfn,
>       int where, int size, u32 *val);
>int pci_generic_config_write(struct pci_bus *bus, unsigned int devfn,
>       int where, int size, u32 val);
>int pci_generic_config_read32(struct pci_bus *bus, unsigned int devfn,
>         int where, int size, u32 *val);
>int pci_generic_config_write32(struct pci_bus *bus, unsigned int devfn,
>          int where, int size, u32 val);
>
>struct pci_ops *pci_bus_set_ops(struct pci_bus *bus, struct pci_ops *ops);
>
>int pci_read_config_byte(const struct pci_dev *dev, int where, u8 *val);
>int pci_read_config_word(const struct pci_dev *dev, int where, u16 *val);
>int pci_read_config_dword(const struct pci_dev *dev, int where, u32 *val);
>int pci_write_config_byte(const struct pci_dev *dev, int where, u8 val);
>int pci_write_config_word(const struct pci_dev *dev, int where, u16 val);
>int pci_write_config_dword(const struct pci_dev *dev, int where, u32 val);
>
>int pcie_capability_read_word(struct pci_dev *dev, int pos, u16 *val);
>int pcie_capability_read_dword(struct pci_dev *dev, int pos, u32 *val);
>int pcie_capability_write_word(struct pci_dev *dev, int pos, u16 val);
>int pcie_capability_write_dword(struct pci_dev *dev, int pos, u32 val);
>int pcie_capability_clear_and_set_word(struct pci_dev *dev, int pos,
>           u16 clear, u16 set);
>int pcie_capability_clear_and_set_dword(struct pci_dev *dev, int pos,
>     u32 clear, u32 set);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pcie_capability_set_word(struct pci_dev *dev, int pos,
>        u16 set)
>{
> return pcie_capability_clear_and_set_word(dev, pos, 0, set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pcie_capability_set_dword(struct pci_dev *dev, int pos,
>         u32 set)
>{
> return pcie_capability_clear_and_set_dword(dev, pos, 0, set);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pcie_capability_clear_word(struct pci_dev *dev, int pos,
>          u16 clear)
>{
> return pcie_capability_clear_and_set_word(dev, pos, clear, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pcie_capability_clear_dword(struct pci_dev *dev, int pos,
>           u32 clear)
>{
> return pcie_capability_clear_and_set_dword(dev, pos, clear, 0);
>}
>
>
>int pci_user_read_config_byte(struct pci_dev *dev, int where, u8 *val);
>int pci_user_read_config_word(struct pci_dev *dev, int where, u16 *val);
>int pci_user_read_config_dword(struct pci_dev *dev, int where, u32 *val);
>int pci_user_write_config_byte(struct pci_dev *dev, int where, u8 val);
>int pci_user_write_config_word(struct pci_dev *dev, int where, u16 val);
>int pci_user_write_config_dword(struct pci_dev *dev, int where, u32 val);
>
>int __attribute__((__warn_unused_result__)) pci_enable_device(struct pci_dev *dev);
>int __attribute__((__warn_unused_result__)) pci_enable_device_io(struct pci_dev *dev);
>int __attribute__((__warn_unused_result__)) pci_enable_device_mem(struct pci_dev *dev);
>int __attribute__((__warn_unused_result__)) pci_reenable_device(struct pci_dev *);
>int __attribute__((__warn_unused_result__)) pcim_enable_device(struct pci_dev *pdev);
>void pcim_pin_device(struct pci_dev *pdev);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_intx_mask_supported(struct pci_dev *pdev)
>{
>
>
>
>
> return !pdev->broken_intx_masking;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_is_enabled(struct pci_dev *pdev)
>{
> return (atomic_read(&pdev->enable_cnt) > 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_is_managed(struct pci_dev *pdev)
>{
> return pdev->is_managed;
>}
>
>void pci_disable_device(struct pci_dev *dev);
>
>extern unsigned int pcibios_max_latency;
>void pci_set_master(struct pci_dev *dev);
>void pci_clear_master(struct pci_dev *dev);
>
>int pci_set_pcie_reset_state(struct pci_dev *dev, enum pcie_reset_state state);
>int pci_set_cacheline_size(struct pci_dev *dev);
>int __attribute__((__warn_unused_result__)) pci_set_mwi(struct pci_dev *dev);
>int __attribute__((__warn_unused_result__)) pcim_set_mwi(struct pci_dev *dev);
>int pci_try_set_mwi(struct pci_dev *dev);
>void pci_clear_mwi(struct pci_dev *dev);
>void pci_disable_parity(struct pci_dev *dev);
>void pci_intx(struct pci_dev *dev, int enable);
>bool pci_check_and_mask_intx(struct pci_dev *dev);
>bool pci_check_and_unmask_intx(struct pci_dev *dev);
>int pci_wait_for_pending(struct pci_dev *dev, int pos, u16 mask);
>int pci_wait_for_pending_transaction(struct pci_dev *dev);
>int pcix_get_max_mmrbc(struct pci_dev *dev);
>int pcix_get_mmrbc(struct pci_dev *dev);
>int pcix_set_mmrbc(struct pci_dev *dev, int mmrbc);
>int pcie_get_readrq(struct pci_dev *dev);
>int pcie_set_readrq(struct pci_dev *dev, int rq);
>int pcie_get_mps(struct pci_dev *dev);
>int pcie_set_mps(struct pci_dev *dev, int mps);
>u32 pcie_bandwidth_available(struct pci_dev *dev, struct pci_dev **limiting_dev,
>        enum pci_bus_speed *speed,
>        enum pcie_link_width *width);
>void pcie_print_link_status(struct pci_dev *dev);
>int pcie_reset_flr(struct pci_dev *dev, bool probe);
>int pcie_flr(struct pci_dev *dev);
>int __pci_reset_function_locked(struct pci_dev *dev);
>int pci_reset_function(struct pci_dev *dev);
>int pci_reset_function_locked(struct pci_dev *dev);
>int pci_try_reset_function(struct pci_dev *dev);
>int pci_probe_reset_slot(struct pci_slot *slot);
>int pci_probe_reset_bus(struct pci_bus *bus);
>int pci_reset_bus(struct pci_dev *dev);
>void pci_reset_secondary_bus(struct pci_dev *dev);
>void pcibios_reset_secondary_bus(struct pci_dev *dev);
>void pci_update_resource(struct pci_dev *dev, int resno);
>int __attribute__((__warn_unused_result__)) pci_assign_resource(struct pci_dev *dev, int i);
>int __attribute__((__warn_unused_result__)) pci_reassign_resource(struct pci_dev *dev, int i, resource_size_t add_size, resource_size_t align);
>void pci_release_resource(struct pci_dev *dev, int resno);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_rebar_bytes_to_size(u64 bytes)
>{
> bytes = ( __builtin_constant_p(bytes) ? ( ((bytes) == 1) ? 1 : (1UL << (( __builtin_constant_p((bytes) - 1) ? (((bytes) - 1) < 2 ? 0 : 63 - __builtin_clzll((bytes) - 1)) : (sizeof((bytes) - 1) <= 4) ? __ilog2_u32((bytes) - 1) : __ilog2_u64((bytes) - 1) ) + 1)) ) : __roundup_pow_of_two(bytes) );
>
>
> return __builtin_choose_expr(((!!(sizeof((typeof(( __builtin_constant_p(bytes) ? ((bytes) < 2 ? 0 : 63 - __builtin_clzll(bytes)) : (sizeof(bytes) <= 4) ? __ilog2_u32(bytes) : __ilog2_u64(bytes) )) *)1 == (typeof(20) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(( __builtin_constant_p(bytes) ? ((bytes) < 2 ? 0 : 63 - __builtin_clzll(bytes)) : (sizeof(bytes) <= 4) ? __ilog2_u32(bytes) : __ilog2_u64(bytes) )) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(20) * 0l)) : (int *)8))))), ((( __builtin_constant_p(bytes) ? ((bytes) < 2 ? 0 : 63 - __builtin_clzll(bytes)) : (sizeof(bytes) <= 4) ? __ilog2_u32(bytes) : __ilog2_u64(bytes) )) > (20) ? (( __builtin_constant_p(bytes) ? ((bytes) < 2 ? 0 : 63 - __builtin_clzll(bytes)) : (sizeof(bytes) <= 4) ? __ilog2_u32(bytes) : __ilog2_u64(bytes) )) : (20)), ({ typeof(( __builtin_constant_p(bytes) ? ((bytes) < 2 ? 0 : 63 - __builtin_clzll(bytes)) : (sizeof(bytes) <= 4) ? __ilog2_u32(bytes) : __ilog2_u64(bytes) )) __UNIQUE_ID___x284 = (( __builtin_constant_p(bytes) ? ((bytes) < 2 ? 0 : 63 - __builtin_clzll(bytes)) : (sizeof(bytes) <= 4) ? __ilog2_u32(bytes) : __ilog2_u64(bytes) )); typeof(20) __UNIQUE_ID___y285 = (20); ((__UNIQUE_ID___x284) > (__UNIQUE_ID___y285) ? (__UNIQUE_ID___x284) : (__UNIQUE_ID___y285)); })) - 20;
>}
>
>u32 pci_rebar_get_possible_sizes(struct pci_dev *pdev, int bar);
>int __attribute__((__warn_unused_result__)) pci_resize_resource(struct pci_dev *dev, int i, int size);
>int pci_select_bars(struct pci_dev *dev, unsigned long flags);
>bool pci_device_is_present(struct pci_dev *pdev);
>void pci_ignore_hotplug(struct pci_dev *dev);
>struct pci_dev *pci_real_dma_dev(struct pci_dev *dev);
>int pci_status_get_and_clear_errors(struct pci_dev *pdev);
>
>int __attribute__((__format__(printf, 6, 7))) pci_request_irq(struct pci_dev *dev, unsigned int nr,
>  irq_handler_t handler, irq_handler_t thread_fn, void *dev_id,
>  const char *fmt, ...);
>void pci_free_irq(struct pci_dev *dev, unsigned int nr, void *dev_id);
>
>
>int pci_enable_rom(struct pci_dev *pdev);
>void pci_disable_rom(struct pci_dev *pdev);
>void __attribute__((__warn_unused_result__)) *pci_map_rom(struct pci_dev *pdev, size_t *size);
>void pci_unmap_rom(struct pci_dev *pdev, void *rom);
>
>
>int pci_save_state(struct pci_dev *dev);
>void pci_restore_state(struct pci_dev *dev);
>struct pci_saved_state *pci_store_saved_state(struct pci_dev *dev);
>int pci_load_saved_state(struct pci_dev *dev,
>    struct pci_saved_state *state);
>int pci_load_and_free_saved_state(struct pci_dev *dev,
>      struct pci_saved_state **state);
>int pci_platform_power_transition(struct pci_dev *dev, pci_power_t state);
>int pci_set_power_state(struct pci_dev *dev, pci_power_t state);
>pci_power_t pci_choose_state(struct pci_dev *dev, pm_message_t state);
>bool pci_pme_capable(struct pci_dev *dev, pci_power_t state);
>void pci_pme_active(struct pci_dev *dev, bool enable);
>int pci_enable_wake(struct pci_dev *dev, pci_power_t state, bool enable);
>int pci_wake_from_d3(struct pci_dev *dev, bool enable);
>int pci_prepare_to_sleep(struct pci_dev *dev);
>int pci_back_from_sleep(struct pci_dev *dev);
>bool pci_dev_run_wake(struct pci_dev *dev);
>void pci_d3cold_enable(struct pci_dev *dev);
>void pci_d3cold_disable(struct pci_dev *dev);
>bool pcie_relaxed_ordering_enabled(struct pci_dev *dev);
>void pci_resume_bus(struct pci_bus *bus);
>void pci_bus_set_current_state(struct pci_bus *bus, pci_power_t state);
>
>
>void set_pcie_port_type(struct pci_dev *pdev);
>void set_pcie_hotplug_bridge(struct pci_dev *pdev);
>
>
>unsigned int pci_rescan_bus_bridge_resize(struct pci_dev *bridge);
>unsigned int pci_rescan_bus(struct pci_bus *bus);
>void pci_lock_rescan_remove(void);
>void pci_unlock_rescan_remove(void);
>
>
>ssize_t pci_read_vpd(struct pci_dev *dev, loff_t pos, size_t count, void *buf);
>ssize_t pci_write_vpd(struct pci_dev *dev, loff_t pos, size_t count, const void *buf);
>
>
>resource_size_t pcibios_retrieve_fw_addr(struct pci_dev *dev, int idx);
>void pci_bus_assign_resources(const struct pci_bus *bus);
>void pci_bus_claim_resources(struct pci_bus *bus);
>void pci_bus_size_bridges(struct pci_bus *bus);
>int pci_claim_resource(struct pci_dev *, int);
>int pci_claim_bridge_resource(struct pci_dev *bridge, int i);
>void pci_assign_unassigned_resources(void);
>void pci_assign_unassigned_bridge_resources(struct pci_dev *bridge);
>void pci_assign_unassigned_bus_resources(struct pci_bus *bus);
>void pci_assign_unassigned_root_bus_resources(struct pci_bus *bus);
>int pci_reassign_bridge_resources(struct pci_dev *bridge, unsigned long type);
>void pdev_enable_device(struct pci_dev *);
>int pci_enable_resources(struct pci_dev *, int mask);
>void pci_assign_irq(struct pci_dev *dev);
>struct resource *pci_find_resource(struct pci_dev *dev, struct resource *res);
>
>int __attribute__((__warn_unused_result__)) pci_request_regions(struct pci_dev *, const char *);
>int __attribute__((__warn_unused_result__)) pci_request_regions_exclusive(struct pci_dev *, const char *);
>void pci_release_regions(struct pci_dev *);
>int __attribute__((__warn_unused_result__)) pci_request_region(struct pci_dev *, int, const char *);
>void pci_release_region(struct pci_dev *, int);
>int pci_request_selected_regions(struct pci_dev *, int, const char *);
>int pci_request_selected_regions_exclusive(struct pci_dev *, int, const char *);
>void pci_release_selected_regions(struct pci_dev *, int);
>
>
>void pci_add_resource(struct list_head *resources, struct resource *res);
>void pci_add_resource_offset(struct list_head *resources, struct resource *res,
>        resource_size_t offset);
>void pci_free_resource_list(struct list_head *resources);
>void pci_bus_add_resource(struct pci_bus *bus, struct resource *res,
>     unsigned int flags);
>struct resource *pci_bus_resource_n(const struct pci_bus *bus, int n);
>void pci_bus_remove_resources(struct pci_bus *bus);
>int devm_request_pci_bus_resources(struct device *dev,
>       struct list_head *resources);
>
>
>int pci_bridge_secondary_bus_reset(struct pci_dev *dev);
>
>
>
>
>
>
>int __attribute__((__warn_unused_result__)) pci_bus_alloc_resource(struct pci_bus *bus,
>   struct resource *res, resource_size_t size,
>   resource_size_t align, resource_size_t min,
>   unsigned long type_mask,
>   resource_size_t (*alignf)(void *,
>        const struct resource *,
>        resource_size_t,
>        resource_size_t),
>   void *alignf_data);
>
>
>int pci_register_io_range(struct fwnode_handle *fwnode, phys_addr_t addr,
>   resource_size_t size);
>unsigned long pci_address_to_pio(phys_addr_t addr);
>phys_addr_t pci_pio_to_address(unsigned long pio);
>int pci_remap_iospace(const struct resource *res, phys_addr_t phys_addr);
>int devm_pci_remap_iospace(struct device *dev, const struct resource *res,
>      phys_addr_t phys_addr);
>void pci_unmap_iospace(struct resource *res);
>void *devm_pci_remap_cfgspace(struct device *dev,
>          resource_size_t offset,
>          resource_size_t size);
>void *devm_pci_remap_cfg_resource(struct device *dev,
>       struct resource *res);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pci_bus_addr_t pci_bus_address(struct pci_dev *pdev, int bar)
>{
> struct pci_bus_region region;
>
> pcibios_resource_to_bus(pdev->bus, &region, &pdev->resource[bar]);
> return region.start;
>}
>
>
>int __attribute__((__warn_unused_result__)) __pci_register_driver(struct pci_driver *, struct module *,
>           const char *mod_name);
>
>
>
>
>
>void pci_unregister_driver(struct pci_driver *dev);
># 1491 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct pci_driver *pci_dev_driver(const struct pci_dev *dev);
>int pci_add_dynid(struct pci_driver *drv,
>    unsigned int vendor, unsigned int device,
>    unsigned int subvendor, unsigned int subdevice,
>    unsigned int class, unsigned int class_mask,
>    unsigned long driver_data);
>const struct pci_device_id *pci_match_id(const struct pci_device_id *ids,
>      struct pci_dev *dev);
>int pci_scan_bridge(struct pci_bus *bus, struct pci_dev *dev, int max,
>      int pass);
>
>void pci_walk_bus(struct pci_bus *top, int (*cb)(struct pci_dev *, void *),
>    void *userdata);
>int pci_cfg_space_size(struct pci_dev *dev);
>unsigned char pci_bus_max_busnr(struct pci_bus *bus);
>void pci_setup_bridge(struct pci_bus *bus);
>resource_size_t pcibios_window_alignment(struct pci_bus *bus,
>      unsigned long type);
>
>
>
>
>int pci_set_vga_state(struct pci_dev *pdev, bool decode,
>        unsigned int command_bits, u32 flags);
># 1529 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dmapool.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/dmapool.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>struct scatterlist {
> unsigned long page_link;
> unsigned int offset;
> unsigned int length;
> dma_addr_t dma_address;
>
> unsigned int dma_length;
>
>
> unsigned int dma_flags;
>
>};
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>struct sg_table {
> struct scatterlist *sgl;
> unsigned int nents;
> unsigned int orig_nents;
>};
>
>struct sg_append_table {
> struct sg_table sgt;
> struct scatterlist *prv;
> unsigned int total_nents;
>};
># 90 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_assign_page(struct scatterlist *sg, struct page *page)
>{
> unsigned long page_link = sg->page_link & (0x01UL | 0x02UL);
>
>
>
>
>
> do { if (__builtin_expect(!!((unsigned long) page & (0x01UL | 0x02UL)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"), "i" (98), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("286" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "286" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
>
>
>
> sg->page_link = page_link | (unsigned long) page;
>}
># 119 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_set_page(struct scatterlist *sg, struct page *page,
>          unsigned int len, unsigned int offset)
>{
> sg_assign_page(sg, page);
> sg->offset = offset;
> sg->length = len;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *sg_page(struct scatterlist *sg)
>{
>
>
>
> return (struct page *)((sg)->page_link & ~(0x01UL | 0x02UL));
>}
># 142 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_set_buf(struct scatterlist *sg, const void *buf,
>         unsigned int buflen)
>{
>
>
>
> sg_set_page(sg, (((struct page *)vmemmap_base) + (__phys_addr_nodebug((unsigned long)(buf)) >> 12)), buflen, ((unsigned long)(buf) & ~(~(((1UL) << 12)-1))));
>}
># 171 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __sg_chain(struct scatterlist *chain_sg,
>         struct scatterlist *sgl)
>{
>
>
>
> chain_sg->offset = 0;
> chain_sg->length = 0;
>
>
>
>
>
> chain_sg->page_link = ((unsigned long) sgl | 0x01UL) & ~0x02UL;
>}
># 197 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_chain(struct scatterlist *prv, unsigned int prv_nents,
>       struct scatterlist *sgl)
>{
> __sg_chain(&prv[prv_nents - 1], sgl);
>}
># 212 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_mark_end(struct scatterlist *sg)
>{
>
>
>
> sg->page_link |= 0x02UL;
> sg->page_link &= ~0x01UL;
>}
># 229 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_unmark_end(struct scatterlist *sg)
>{
> sg->page_link &= ~0x02UL;
>}
># 253 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool sg_is_dma_bus_address(struct scatterlist *sg)
>{
> return sg->dma_flags & (1 << 0);
>}
># 268 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_dma_mark_bus_address(struct scatterlist *sg)
>{
> sg->dma_flags |= (1 << 0);
>}
># 280 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_dma_unmark_bus_address(struct scatterlist *sg)
>{
> sg->dma_flags &= ~(1 << 0);
>}
># 310 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dma_addr_t sg_phys(struct scatterlist *sg)
>{
> return ((dma_addr_t)(unsigned long)((sg_page(sg)) - ((struct page *)vmemmap_base)) << 12) + sg->offset;
>}
># 325 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *sg_virt(struct scatterlist *sg)
>{
> return lowmem_page_address(sg_page(sg)) + sg->offset;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sg_init_marker(struct scatterlist *sgl,
>      unsigned int nents)
>{
> sg_mark_end(&sgl[nents - 1]);
>}
>
>int sg_nents(struct scatterlist *sg);
>int sg_nents_for_len(struct scatterlist *sg, u64 len);
>struct scatterlist *sg_next(struct scatterlist *);
>struct scatterlist *sg_last(struct scatterlist *s, unsigned int);
>void sg_init_table(struct scatterlist *, unsigned int);
>void sg_init_one(struct scatterlist *, const void *, unsigned int);
>int sg_split(struct scatterlist *in, const int in_mapped_nents,
>      const off_t skip, const int nb_splits,
>      const size_t *split_sizes,
>      struct scatterlist **out, int *out_mapped_nents,
>      gfp_t gfp_mask);
>
>typedef struct scatterlist *(sg_alloc_fn)(unsigned int, gfp_t);
>typedef void (sg_free_fn)(struct scatterlist *, unsigned int);
>
>void __sg_free_table(struct sg_table *, unsigned int, unsigned int,
>       sg_free_fn *, unsigned int);
>void sg_free_table(struct sg_table *);
>void sg_free_append_table(struct sg_append_table *sgt);
>int __sg_alloc_table(struct sg_table *, unsigned int, unsigned int,
>       struct scatterlist *, unsigned int, gfp_t, sg_alloc_fn *);
>int sg_alloc_table(struct sg_table *, unsigned int, gfp_t);
>int sg_alloc_append_table_from_pages(struct sg_append_table *sgt,
>         struct page **pages, unsigned int n_pages,
>         unsigned int offset, unsigned long size,
>         unsigned int max_segment,
>         unsigned int left_pages, gfp_t gfp_mask);
>int sg_alloc_table_from_pages_segment(struct sg_table *sgt, struct page **pages,
>          unsigned int n_pages, unsigned int offset,
>          unsigned long size,
>          unsigned int max_segment, gfp_t gfp_mask);
># 394 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int sg_alloc_table_from_pages(struct sg_table *sgt,
>         struct page **pages,
>         unsigned int n_pages,
>         unsigned int offset,
>         unsigned long size, gfp_t gfp_mask)
>{
> return sg_alloc_table_from_pages_segment(sgt, pages, n_pages, offset,
>       size, (~0U), gfp_mask);
>}
>
>
>struct scatterlist *sgl_alloc_order(unsigned long long length,
>        unsigned int order, bool chainable,
>        gfp_t gfp, unsigned int *nent_p);
>struct scatterlist *sgl_alloc(unsigned long long length, gfp_t gfp,
>         unsigned int *nent_p);
>void sgl_free_n_order(struct scatterlist *sgl, int nents, int order);
>void sgl_free_order(struct scatterlist *sgl, int order);
>void sgl_free(struct scatterlist *sgl);
>
>
>size_t sg_copy_buffer(struct scatterlist *sgl, unsigned int nents, void *buf,
>        size_t buflen, off_t skip, bool to_buffer);
>
>size_t sg_copy_from_buffer(struct scatterlist *sgl, unsigned int nents,
>      const void *buf, size_t buflen);
>size_t sg_copy_to_buffer(struct scatterlist *sgl, unsigned int nents,
>    void *buf, size_t buflen);
>
>size_t sg_pcopy_from_buffer(struct scatterlist *sgl, unsigned int nents,
>       const void *buf, size_t buflen, off_t skip);
>size_t sg_pcopy_to_buffer(struct scatterlist *sgl, unsigned int nents,
>     void *buf, size_t buflen, off_t skip);
>size_t sg_zero_buffer(struct scatterlist *sgl, unsigned int nents,
>         size_t buflen, off_t skip);
># 456 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>void sg_free_table_chained(struct sg_table *table,
>      unsigned nents_first_chunk);
>int sg_alloc_table_chained(struct sg_table *table, int nents,
>      struct scatterlist *first_chunk,
>      unsigned nents_first_chunk);
># 473 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>struct sg_page_iter {
> struct scatterlist *sg;
> unsigned int sg_pgoffset;
>
>
> unsigned int __nents;
> int __pg_advance;
>
>};
># 490 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>struct sg_dma_page_iter {
> struct sg_page_iter base;
>};
>
>bool __sg_page_iter_next(struct sg_page_iter *piter);
>bool __sg_page_iter_dma_next(struct sg_dma_page_iter *dma_iter);
>void __sg_page_iter_start(struct sg_page_iter *piter,
>     struct scatterlist *sglist, unsigned int nents,
>     unsigned long pgoffset);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *sg_page_iter_page(struct sg_page_iter *piter)
>{
> return ((sg_page(piter->sg)) + (piter->sg_pgoffset));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dma_addr_t
>sg_page_iter_dma_address(struct sg_dma_page_iter *dma_iter)
>{
> return ((dma_iter->base.sg)->dma_address) +
>        (dma_iter->base.sg_pgoffset << 12);
>}
># 598 "/usr/src/linux-5.14.21-150500.53/include/linux/scatterlist.h"
>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;
>};
>
>void sg_miter_start(struct sg_mapping_iter *miter, struct scatterlist *sgl,
>      unsigned int nents, unsigned int flags);
>bool sg_miter_skip(struct sg_mapping_iter *miter, off_t offset);
>bool sg_miter_next(struct sg_mapping_iter *miter);
>void sg_miter_stop(struct sg_mapping_iter *miter);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/dmapool.h" 2
>
>
>struct device;
>
>
>
>struct dma_pool *dma_pool_create(const char *name, struct device *dev,
>   size_t size, size_t align, size_t allocation);
>
>void dma_pool_destroy(struct dma_pool *pool);
>
>void *dma_pool_alloc(struct dma_pool *pool, gfp_t mem_flags,
>       dma_addr_t *handle);
>void dma_pool_free(struct dma_pool *pool, void *vaddr, dma_addr_t addr);
>
>
>
>
>struct dma_pool *dmam_pool_create(const char *name, struct device *dev,
>      size_t size, size_t align, size_t allocation);
>void dmam_pool_destroy(struct dma_pool *pool);
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/dmapool.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dma_pool_zalloc(struct dma_pool *pool, gfp_t mem_flags,
>        dma_addr_t *handle)
>{
> return dma_pool_alloc(pool, mem_flags | (( gfp_t)0x100u), handle);
>}
># 1530 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 1540 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct msix_entry {
> u32 vector;
> u16 entry;
>};
>
>
>int pci_msi_vec_count(struct pci_dev *dev);
>void pci_disable_msi(struct pci_dev *dev);
>int pci_msix_vec_count(struct pci_dev *dev);
>void pci_disable_msix(struct pci_dev *dev);
>void pci_restore_msi_state(struct pci_dev *dev);
>int pci_msi_enabled(void);
>int pci_enable_msi(struct pci_dev *dev);
>int pci_enable_msix_range(struct pci_dev *dev, struct msix_entry *entries,
>     int minvec, int maxvec);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_enable_msix_exact(struct pci_dev *dev,
>     struct msix_entry *entries, int nvec)
>{
> int rc = pci_enable_msix_range(dev, entries, nvec, nvec);
> if (rc < 0)
>  return rc;
> return 0;
>}
>int pci_alloc_irq_vectors_affinity(struct pci_dev *dev, unsigned int min_vecs,
>       unsigned int max_vecs, unsigned int flags,
>       struct irq_affinity *affd);
>
>void pci_free_irq_vectors(struct pci_dev *dev);
>int pci_irq_vector(struct pci_dev *dev, unsigned int nr);
>const struct cpumask *pci_irq_get_affinity(struct pci_dev *pdev, int vec);
># 1630 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_irqd_intx_xlate(struct irq_domain *d,
>          struct device_node *node,
>          const u32 *intspec,
>          unsigned int intsize,
>          unsigned long *out_hwirq,
>          unsigned int *out_type)
>{
> const u32 intx = intspec[0];
>
> if (intx < PCI_INTERRUPT_INTA || intx > PCI_INTERRUPT_INTD)
>  return -22;
>
> *out_hwirq = intx - PCI_INTERRUPT_INTA;
> return 0;
>}
>
>
>extern bool pcie_ports_disabled;
>extern bool pcie_ports_native;
># 1663 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>int pci_disable_link_state(struct pci_dev *pdev, int state);
>int pci_disable_link_state_locked(struct pci_dev *pdev, int state);
>void pcie_no_aspm(void);
>bool pcie_aspm_support_enabled(void);
>bool pcie_aspm_enabled(struct pci_dev *pdev);
># 1679 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>bool pci_aer_available(void);
>
>
>
>
>bool pci_ats_disabled(void);
>
>
>int pci_enable_ptm(struct pci_dev *dev, u8 *granularity);
>bool pcie_ptm_enabled(struct pci_dev *dev);
>
>
>
>
>
>
>
>void pci_cfg_access_lock(struct pci_dev *dev);
>bool pci_cfg_access_trylock(struct pci_dev *dev);
>void pci_cfg_access_unlock(struct pci_dev *dev);
>
>void pci_dev_lock(struct pci_dev *dev);
>int pci_dev_trylock(struct pci_dev *dev);
>void pci_dev_unlock(struct pci_dev *dev);
>
>
>
>
>
>
>
>extern int pci_domains_supported;
># 1737 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>typedef int (*arch_set_vga_state_t)(struct pci_dev *pdev, bool decode,
>        unsigned int command_bits, u32 flags);
>void pci_register_set_vga_state(arch_set_vga_state_t func);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>pci_request_io_regions(struct pci_dev *pdev, const char *name)
>{
> return pci_request_selected_regions(pdev,
>       pci_select_bars(pdev, 0x00000100), name);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_release_io_regions(struct pci_dev *pdev)
>{
> return pci_release_selected_regions(pdev,
>       pci_select_bars(pdev, 0x00000100));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>pci_request_mem_regions(struct pci_dev *pdev, const char *name)
>{
> return pci_request_selected_regions(pdev,
>       pci_select_bars(pdev, 0x00000200), name);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_release_mem_regions(struct pci_dev *pdev)
>{
> return pci_release_selected_regions(pdev,
>       pci_select_bars(pdev, 0x00000200));
>}
># 1905 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>pci_alloc_irq_vectors(struct pci_dev *dev, unsigned int min_vecs,
>        unsigned int max_vecs, unsigned int flags)
>{
> return pci_alloc_irq_vectors_affinity(dev, min_vecs, max_vecs, flags,
>           ((void *)0));
>}
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pci.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pci.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/memtype.h" 1
>
>
>
>
>
>
>
>extern bool pat_enabled(void);
>extern void pat_disable(const char *reason);
>extern void pat_init(void);
>extern void init_cache_modes(void);
>
>extern int memtype_reserve(u64 start, u64 end,
>  enum page_cache_mode req_pcm, enum page_cache_mode *ret_pcm);
>extern int memtype_free(u64 start, u64 end);
>
>extern int memtype_kernel_map_sync(u64 base, unsigned long size,
>  enum page_cache_mode pcm);
>
>extern int memtype_reserve_io(resource_size_t start, resource_size_t end,
>   enum page_cache_mode *pcm);
>
>extern void memtype_free_io(resource_size_t start, resource_size_t end);
>
>extern bool pat_pfn_immune_to_uc_mtrr(unsigned long pfn);
>
>bool x86_has_pat_wp(void);
>enum page_cache_mode pgprot2cachemode(pgprot_t pgprot);
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pci.h" 2
>
>
>struct pci_sysdata {
> int domain;
> int node;
>
> struct acpi_device *companion;
>
>
> void *iommu;
>
>
> void *fwnode;
>
>
> struct pci_dev *vmd_dev;
>
>};
>
>extern int pci_routeirq;
>extern int noioapicquirk;
>extern int noioapicreroute;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pci_sysdata *to_pci_sysdata(const struct pci_bus *bus)
>{
> return bus->sysdata;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_domain_nr(struct pci_bus *bus)
>{
> return to_pci_sysdata(bus)->domain;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_proc_domain(struct pci_bus *bus)
>{
> return pci_domain_nr(bus);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *_pci_root_bus_fwnode(struct pci_bus *bus)
>{
> return to_pci_sysdata(bus)->fwnode;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_vmd(struct pci_bus *bus)
>{
> return to_pci_sysdata(bus)->vmd_dev != ((void *)0);
>}
># 77 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pci.h"
>extern unsigned int pcibios_assign_all_busses(void);
>extern int pci_legacy_init(void);
>
>
>
>
>extern unsigned long pci_mem_start;
>
>
>
>
>
>extern int pcibios_enabled;
>void pcibios_scan_root(int bus);
>
>struct irq_routing_table *pcibios_get_irq_routing_table(void);
>int pcibios_set_irq_routing(struct pci_dev *dev, int pin, int irq);
>
>
>
>
>
>
>
>extern void early_quirks(void);
>
>
>
>
>extern void pci_iommu_alloc(void);
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/pci.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_get_legacy_ide_irq(struct pci_dev *dev, int channel)
>{
> return channel ? 15 : 14;
>}
># 110 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/pci.h" 2
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __pcibus_to_node(const struct pci_bus *bus)
>{
> return to_pci_sysdata(bus)->node;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct cpumask *
>cpumask_of_pcibus(const struct pci_bus *bus)
>{
> int node;
>
> node = __pcibus_to_node(bus);
> return (node == (-1)) ? ((const struct cpumask *)&__cpu_online_mask) :
>         cpumask_of_node(node);
>}
>
>
>struct pci_setup_rom {
> struct setup_data data;
> uint16_t vendor;
> uint16_t devid;
> uint64_t pcilen;
> unsigned long segment;
> unsigned long bus;
> unsigned long device;
> unsigned long function;
> uint8_t romdata[];
>};
># 1916 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 1929 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>int pci_mmap_resource_range(struct pci_dev *dev, int bar,
>       struct vm_area_struct *vma,
>       enum pci_mmap_state mmap_state, int write_combine);
>int pci_mmap_page_range(struct pci_dev *pdev, int bar,
>   struct vm_area_struct *vma,
>   enum pci_mmap_state mmap_state, int write_combine);
># 1971 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *pci_get_drvdata(struct pci_dev *pdev)
>{
> return dev_get_drvdata(&pdev->dev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pci_set_drvdata(struct pci_dev *pdev, void *data)
>{
> dev_set_drvdata(&pdev->dev, data);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *pci_name(const struct pci_dev *pdev)
>{
> return dev_name(&pdev->dev);
>}
>
>void pci_resource_to_user(const struct pci_dev *dev, int bar,
>     const struct resource *rsrc,
>     resource_size_t *start, resource_size_t *end);
># 1997 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>struct pci_fixup {
> u16 vendor;
> u16 device;
> u32 class;
> unsigned int class_shift;
>
> int hook_offset;
>
>
>
>};
>
>enum pci_fixup_pass {
> pci_fixup_early,
> pci_fixup_header,
> pci_fixup_final,
> pci_fixup_enable,
> pci_fixup_resume,
> pci_fixup_suspend,
> pci_fixup_resume_early,
> pci_fixup_suspend_late,
>};
># 2125 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>void pci_fixup_device(enum pci_fixup_pass pass, struct pci_dev *dev);
>
>
>
>
>
>void *pcim_iomap(struct pci_dev *pdev, int bar, unsigned long maxlen);
>void pcim_iounmap(struct pci_dev *pdev, void *addr);
>void * const *pcim_iomap_table(struct pci_dev *pdev);
>int pcim_iomap_regions(struct pci_dev *pdev, int mask, const char *name);
>int pcim_iomap_regions_request_all(struct pci_dev *pdev, int mask,
>       const char *name);
>void pcim_iounmap_regions(struct pci_dev *pdev, int mask);
>
>extern int pci_pci_problems;
># 2148 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>extern unsigned long pci_cardbus_io_size;
>extern unsigned long pci_cardbus_mem_size;
>extern u8 pci_dfl_cache_line_size;
>extern u8 pci_cache_line_size;
>
>
>void pcibios_disable_device(struct pci_dev *dev);
>void pcibios_set_master(struct pci_dev *dev);
>int pcibios_set_pcie_reset_state(struct pci_dev *dev,
>     enum pcie_reset_state state);
>int pcibios_device_add(struct pci_dev *dev);
>void pcibios_release_device(struct pci_dev *dev);
>
>void pcibios_penalize_isa_irq(int irq, int active);
>
>
>
>int pcibios_alloc_irq(struct pci_dev *dev);
>void pcibios_free_irq(struct pci_dev *dev);
>resource_size_t pcibios_default_alignment(void);
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pci_mmcfg_early_init(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pci_mmcfg_late_init(void);
>
>
>
>
>
>int pci_ext_cfg_avail(void);
>
>void *pci_ioremap_bar(struct pci_dev *pdev, int bar);
>void *pci_ioremap_wc_bar(struct pci_dev *pdev, int bar);
>
>
>int pci_iov_virtfn_bus(struct pci_dev *dev, int id);
>int pci_iov_virtfn_devfn(struct pci_dev *dev, int id);
>int pci_iov_vf_id(struct pci_dev *dev);
>void *pci_iov_get_pf_drvdata(struct pci_dev *dev, struct pci_driver *pf_driver);
>int pci_enable_sriov(struct pci_dev *dev, int nr_virtfn);
>void pci_disable_sriov(struct pci_dev *dev);
>
>int pci_iov_sysfs_link(struct pci_dev *dev, struct pci_dev *virtfn, int id);
>int pci_iov_add_virtfn(struct pci_dev *dev, int id);
>void pci_iov_remove_virtfn(struct pci_dev *dev, int id);
>int pci_num_vf(struct pci_dev *dev);
>int pci_vfs_assigned(struct pci_dev *dev);
>int pci_sriov_set_totalvfs(struct pci_dev *dev, u16 numvfs);
>int pci_sriov_get_totalvfs(struct pci_dev *dev);
>int pci_sriov_configure_simple(struct pci_dev *dev, int nr_virtfn);
>resource_size_t pci_iov_resource_size(struct pci_dev *dev, int resno);
>void pci_vf_drivers_autoprobe(struct pci_dev *dev, bool probe);
>
>
>int pcibios_sriov_enable(struct pci_dev *pdev, u16 num_vfs);
>int pcibios_sriov_disable(struct pci_dev *pdev);
>resource_size_t pcibios_iov_resource_alignment(struct pci_dev *dev, int resno);
># 2255 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>void pci_hp_create_module_link(struct pci_slot *pci_slot);
>void pci_hp_remove_module_link(struct pci_slot *pci_slot);
># 2270 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_pcie_cap(struct pci_dev *dev)
>{
> return dev->pcie_cap;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_is_pcie(struct pci_dev *dev)
>{
> return pci_pcie_cap(dev);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 pcie_caps_reg(const struct pci_dev *dev)
>{
> return dev->pcie_flags_reg;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_pcie_type(const struct pci_dev *dev)
>{
> return (pcie_caps_reg(dev) & 0x00f0) >> 4;
>}
># 2311 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pci_dev *pcie_find_root_port(struct pci_dev *dev)
>{
> while (dev) {
>  if (pci_is_pcie(dev) &&
>      pci_pcie_type(dev) == 0x4)
>   return dev;
>  dev = pci_upstream_bridge(dev);
> }
>
> return ((void *)0);
>}
>
>void pci_request_acs(void);
>bool pci_acs_enabled(struct pci_dev *pdev, u16 acs_flags);
>bool pci_acs_path_enabled(struct pci_dev *start,
>     struct pci_dev *end, u16 acs_flags);
>int pci_enable_atomic_ops_to_root(struct pci_dev *dev, u32 cap_mask);
># 2367 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 pci_vpd_lrdt_size(const u8 *lrdt)
>{
> return (u16)lrdt[1] + ((u16)lrdt[2] << 8);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 pci_vpd_lrdt_tag(const u8 *lrdt)
>{
> return (u16)(lrdt[0] & 0x7f);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 pci_vpd_srdt_size(const u8 *srdt)
>{
> return (*srdt) & 0x07;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 pci_vpd_srdt_tag(const u8 *srdt)
>{
> return ((*srdt) & 0x78) >> 3;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 pci_vpd_info_field_size(const u8 *info_field)
>{
> return info_field[2];
>}
># 2423 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>void *pci_vpd_alloc(struct pci_dev *dev, unsigned int *size);
># 2433 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>int pci_vpd_find_id_string(const u8 *buf, unsigned int len, unsigned int *size);
># 2445 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>int pci_vpd_find_ro_info_keyword(const void *buf, unsigned int len,
>     const char *kw, unsigned int *size);
># 2455 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>int pci_vpd_check_csum(const void *buf, unsigned int len);
># 2468 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *
>pci_host_bridge_of_msi_domain(struct pci_bus *bus) { return ((void *)0); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_host_of_has_msi_map(struct device *dev) { return false; }
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *
>pci_device_to_OF_node(const struct pci_dev *pdev)
>{
> return pdev ? pdev->dev.of_node : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *pci_bus_to_OF_node(struct pci_bus *bus)
>{
> return bus ? bus->dev.of_node : ((void *)0);
>}
>
>
>struct irq_domain *pci_host_bridge_acpi_msi_domain(struct pci_bus *bus);
>
>void
>pci_msi_register_fwnode_provider(struct fwnode_handle *(*fn)(struct device *));
>bool pci_pr3_present(struct pci_dev *pdev);
># 2503 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>void pci_add_dma_alias(struct pci_dev *dev, u8 devfn_from, unsigned nr_devfns);
>bool pci_devs_are_dma_aliases(struct pci_dev *dev1, struct pci_dev *dev2);
>int pci_for_each_dma_alias(struct pci_dev *pdev,
>      int (*fn)(struct pci_dev *pdev,
>         u16 alias, void *data), void *data);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pci_set_dev_assigned(struct pci_dev *pdev)
>{
> pdev->dev_flags |= PCI_DEV_FLAGS_ASSIGNED;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pci_clear_dev_assigned(struct pci_dev *pdev)
>{
> pdev->dev_flags &= ~PCI_DEV_FLAGS_ASSIGNED;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_is_dev_assigned(struct pci_dev *pdev)
>{
> return (pdev->dev_flags & PCI_DEV_FLAGS_ASSIGNED) == PCI_DEV_FLAGS_ASSIGNED;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_ari_enabled(struct pci_bus *bus)
>{
> return bus->self && bus->self->ari_enabled;
>}
># 2542 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pci_is_thunderbolt_attached(struct pci_dev *pdev)
>{
> struct pci_dev *parent = pdev;
>
> if (pdev->is_thunderbolt)
>  return true;
>
> while ((parent = pci_upstream_bridge(parent)))
>  if (parent->is_thunderbolt)
>   return true;
>
> return false;
>}
>
>
>void pci_uevent_ers(struct pci_dev *pdev, enum pci_ers_result err_type);
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pci-dma-compat.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-direction.h" 1
>
>
>
>
>enum dma_data_direction {
> DMA_BIDIRECTIONAL = 0,
> DMA_TO_DEVICE = 1,
> DMA_FROM_DEVICE = 2,
> DMA_NONE = 3,
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int valid_dma_direction(enum dma_data_direction dir)
>{
> return dir == DMA_BIDIRECTIONAL || dir == DMA_TO_DEVICE ||
>  dir == DMA_FROM_DEVICE;
>}
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h" 2
># 83 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_dma_mapping_error(struct device *dev,
>  dma_addr_t dma_addr)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_dma_map_single(struct device *dev, const void *addr,
>  unsigned long len)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_mapping_error(struct device *dev, dma_addr_t dma_addr)
>{
> debug_dma_mapping_error(dev, dma_addr);
>
> if (__builtin_expect(!!(dma_addr == (~(dma_addr_t)0)), 0))
>  return -12;
> return 0;
>}
>
>dma_addr_t dma_map_page_attrs(struct device *dev, struct page *page,
>  size_t offset, size_t size, enum dma_data_direction dir,
>  unsigned long attrs);
>void dma_unmap_page_attrs(struct device *dev, dma_addr_t addr, size_t size,
>  enum dma_data_direction dir, unsigned long attrs);
>int dma_map_sg_attrs(struct device *dev, struct scatterlist *sg, int nents,
>  enum dma_data_direction dir, unsigned long attrs);
>void dma_unmap_sg_attrs(struct device *dev, struct scatterlist *sg,
>          int nents, enum dma_data_direction dir,
>          unsigned long attrs);
>int dma_map_sgtable(struct device *dev, struct sg_table *sgt,
>  enum dma_data_direction dir, unsigned long attrs);
>dma_addr_t dma_map_resource(struct device *dev, phys_addr_t phys_addr,
>  size_t size, enum dma_data_direction dir, unsigned long attrs);
>void dma_unmap_resource(struct device *dev, dma_addr_t addr, size_t size,
>  enum dma_data_direction dir, unsigned long attrs);
>void dma_sync_single_for_cpu(struct device *dev, dma_addr_t addr, size_t size,
>  enum dma_data_direction dir);
>void dma_sync_single_for_device(struct device *dev, dma_addr_t addr,
>  size_t size, enum dma_data_direction dir);
>void dma_sync_sg_for_cpu(struct device *dev, struct scatterlist *sg,
>      int nelems, enum dma_data_direction dir);
>void dma_sync_sg_for_device(struct device *dev, struct scatterlist *sg,
>         int nelems, enum dma_data_direction dir);
>void *dma_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
>  gfp_t flag, unsigned long attrs);
>void dma_free_attrs(struct device *dev, size_t size, void *cpu_addr,
>  dma_addr_t dma_handle, unsigned long attrs);
>void *dmam_alloc_attrs(struct device *dev, size_t size, dma_addr_t *dma_handle,
>  gfp_t gfp, unsigned long attrs);
>void dmam_free_coherent(struct device *dev, size_t size, void *vaddr,
>  dma_addr_t dma_handle);
>int dma_get_sgtable_attrs(struct device *dev, struct sg_table *sgt,
>  void *cpu_addr, dma_addr_t dma_addr, size_t size,
>  unsigned long attrs);
>int dma_mmap_attrs(struct device *dev, struct vm_area_struct *vma,
>  void *cpu_addr, dma_addr_t dma_addr, size_t size,
>  unsigned long attrs);
>bool dma_can_mmap(struct device *dev);
>int dma_supported(struct device *dev, u64 mask);
>bool dma_pci_p2pdma_supported(struct device *dev);
>int dma_set_mask(struct device *dev, u64 mask);
>int dma_set_coherent_mask(struct device *dev, u64 mask);
>u64 dma_get_required_mask(struct device *dev);
>size_t dma_max_mapping_size(struct device *dev);
>size_t dma_opt_mapping_size(struct device *dev);
>bool dma_need_sync(struct device *dev, dma_addr_t dma_addr);
>unsigned long dma_get_merge_boundary(struct device *dev);
>struct sg_table *dma_alloc_noncontiguous(struct device *dev, size_t size,
>  enum dma_data_direction dir, gfp_t gfp, unsigned long attrs);
>void dma_free_noncontiguous(struct device *dev, size_t size,
>  struct sg_table *sgt, enum dma_data_direction dir);
>void *dma_vmap_noncontiguous(struct device *dev, size_t size,
>  struct sg_table *sgt);
>void dma_vunmap_noncontiguous(struct device *dev, void *vaddr);
>int dma_mmap_noncontiguous(struct device *dev, struct vm_area_struct *vma,
>  size_t size, struct sg_table *sgt);
># 311 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>struct page *dma_alloc_pages(struct device *dev, size_t size,
>  dma_addr_t *dma_handle, enum dma_data_direction dir, gfp_t gfp);
>void dma_free_pages(struct device *dev, size_t size, struct page *page,
>  dma_addr_t dma_handle, enum dma_data_direction dir);
>int dma_mmap_pages(struct device *dev, struct vm_area_struct *vma,
>  size_t size, struct page *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dma_alloc_noncoherent(struct device *dev, size_t size,
>  dma_addr_t *dma_handle, enum dma_data_direction dir, gfp_t gfp)
>{
> struct page *page = dma_alloc_pages(dev, size, dma_handle, dir, gfp);
> return page ? lowmem_page_address(page) : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_free_noncoherent(struct device *dev, size_t size,
>  void *vaddr, dma_addr_t dma_handle, enum dma_data_direction dir)
>{
> dma_free_pages(dev, size, (((struct page *)vmemmap_base) + (__phys_addr_nodebug((unsigned long)(vaddr)) >> 12)), dma_handle, dir);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dma_addr_t dma_map_single_attrs(struct device *dev, void *ptr,
>  size_t size, enum dma_data_direction dir, unsigned long attrs)
>{
>
> if (({ static bool __attribute__((__section__(".data.once"))) __already_done; bool __ret_do_once = !!(is_vmalloc_addr(ptr)); if (__builtin_expect(!!(__ret_do_once && !__already_done), 0)) { __already_done = true; ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("%s %s: " "rejecting DMA map of vmalloc memory\n", dev_driver_string(dev), dev_name(dev)); do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" (
>                                            "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
># 335 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>     ), "i" (
>                                            336
># 335 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>     ), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("287" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "287" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } __builtin_expect(!!(__ret_do_once), 0); })
>                                             )
>  return (~(dma_addr_t)0);
> debug_dma_map_single(dev, ptr, size);
> return dma_map_page_attrs(dev, (((struct page *)vmemmap_base) + (__phys_addr_nodebug((unsigned long)(ptr)) >> 12)), ((unsigned long)(ptr) & ~(~(((1UL) << 12)-1))),
>   size, dir, attrs);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_unmap_single_attrs(struct device *dev, dma_addr_t addr,
>  size_t size, enum dma_data_direction dir, unsigned long attrs)
>{
> return dma_unmap_page_attrs(dev, addr, size, dir, attrs);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_sync_single_range_for_cpu(struct device *dev,
>  dma_addr_t addr, unsigned long offset, size_t size,
>  enum dma_data_direction dir)
>{
> return dma_sync_single_for_cpu(dev, addr + offset, size, dir);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_sync_single_range_for_device(struct device *dev,
>  dma_addr_t addr, unsigned long offset, size_t size,
>  enum dma_data_direction dir)
>{
> return dma_sync_single_for_device(dev, addr + offset, size, dir);
>}
># 374 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_unmap_sgtable(struct device *dev, struct sg_table *sgt,
>  enum dma_data_direction dir, unsigned long attrs)
>{
> dma_unmap_sg_attrs(dev, sgt->sgl, sgt->orig_nents, dir, attrs);
>}
># 392 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_sync_sgtable_for_cpu(struct device *dev,
>  struct sg_table *sgt, enum dma_data_direction dir)
>{
> dma_sync_sg_for_cpu(dev, sgt->sgl, sgt->orig_nents, dir);
>}
># 409 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_sync_sgtable_for_device(struct device *dev,
>  struct sg_table *sgt, enum dma_data_direction dir)
>{
> dma_sync_sg_for_device(dev, sgt->sgl, sgt->orig_nents, dir);
>}
># 424 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dma_alloc_coherent(struct device *dev, size_t size,
>  dma_addr_t *dma_handle, gfp_t gfp)
>{
> return dma_alloc_attrs(dev, size, dma_handle, gfp,
>   (gfp & (( gfp_t)0x2000u)) ? (1UL << 8) : 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_free_coherent(struct device *dev, size_t size,
>  void *cpu_addr, dma_addr_t dma_handle)
>{
> return dma_free_attrs(dev, size, cpu_addr, dma_handle, 0);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 dma_get_mask(struct device *dev)
>{
> if (dev->dma_mask && *dev->dma_mask)
>  return *dev->dma_mask;
> return (((32) == 64) ? ~0ULL : ((1ULL<<(32))-1));
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_set_mask_and_coherent(struct device *dev, u64 mask)
>{
> int rc = dma_set_mask(dev, mask);
> if (rc == 0)
>  dma_set_coherent_mask(dev, mask);
> return rc;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_coerce_mask_and_coherent(struct device *dev, u64 mask)
>{
> dev->dma_mask = &dev->coherent_dma_mask;
> return dma_set_mask_and_coherent(dev, mask);
>}
># 477 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dma_addressing_limited(struct device *dev)
>{
> return ({ typeof(dma_get_mask(dev)) __x = (dma_get_mask(dev)); typeof(dev->bus_dma_limit) __y = (dev->bus_dma_limit); __x == 0 ? __y : ((__y == 0) ? __x : __builtin_choose_expr(((!!(sizeof((typeof(__x) *)1 == (typeof(__y) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(__x) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(__y) * 0l)) : (int *)8))))), ((__x) < (__y) ? (__x) : (__y)), ({ typeof(__x) __UNIQUE_ID___x288 = (__x); typeof(__y) __UNIQUE_ID___y289 = (__y); ((__UNIQUE_ID___x288) < (__UNIQUE_ID___y289) ? (__UNIQUE_ID___x288) : (__UNIQUE_ID___y289)); }))); }) <
>       dma_get_required_mask(dev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int dma_get_max_seg_size(struct device *dev)
>{
> if (dev->dma_parms && dev->dma_parms->max_segment_size)
>  return dev->dma_parms->max_segment_size;
> return 0x00010000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_set_max_seg_size(struct device *dev, unsigned int size)
>{
> if (dev->dma_parms) {
>  dev->dma_parms->max_segment_size = size;
>  return 0;
> }
> return -5;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long dma_get_seg_boundary(struct device *dev)
>{
> if (dev->dma_parms && dev->dma_parms->segment_boundary_mask)
>  return dev->dma_parms->segment_boundary_mask;
> return (~0UL);
>}
># 517 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long dma_get_seg_boundary_nr_pages(struct device *dev,
>  unsigned int page_shift)
>{
> if (!dev)
>  return (((u32)~0U) >> page_shift) + 1;
> return (dma_get_seg_boundary(dev) >> page_shift) + 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_set_seg_boundary(struct device *dev, unsigned long mask)
>{
> if (dev->dma_parms) {
>  dev->dma_parms->segment_boundary_mask = mask;
>  return 0;
> }
> return -5;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int dma_get_min_align_mask(struct device *dev)
>{
> if (dev->dma_parms)
>  return dev->dma_parms->min_align_mask;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_set_min_align_mask(struct device *dev,
>  unsigned int min_align_mask)
>{
> if (({ int __ret_warn_on = !!(!dev->dma_parms); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/dma-mapping.h"), "i" (544), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("290" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "290" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }))
>  return -5;
> dev->dma_parms->min_align_mask = min_align_mask;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_get_cache_alignment(void)
>{
>
>
>
> return 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dmam_alloc_coherent(struct device *dev, size_t size,
>  dma_addr_t *dma_handle, gfp_t gfp)
>{
> return dmam_alloc_attrs(dev, size, dma_handle, gfp,
>   (gfp & (( gfp_t)0x2000u)) ? (1UL << 8) : 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dma_alloc_wc(struct device *dev, size_t size,
>     dma_addr_t *dma_addr, gfp_t gfp)
>{
> unsigned long attrs = (1UL << 2);
>
> if (gfp & (( gfp_t)0x2000u))
>  attrs |= (1UL << 8);
>
> return dma_alloc_attrs(dev, size, dma_addr, gfp, attrs);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_free_wc(struct device *dev, size_t size,
>          void *cpu_addr, dma_addr_t dma_addr)
>{
> return dma_free_attrs(dev, size, cpu_addr, dma_addr,
>         (1UL << 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_mmap_wc(struct device *dev,
>         struct vm_area_struct *vma,
>         void *cpu_addr, dma_addr_t dma_addr,
>         size_t size)
>{
> return dma_mmap_attrs(dev, vma, cpu_addr, dma_addr, size,
>         (1UL << 2));
>}
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/pci-dma-compat.h" 2
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *
>pci_alloc_consistent(struct pci_dev *hwdev, size_t size,
>       dma_addr_t *dma_handle)
>{
> return dma_alloc_coherent(&hwdev->dev, size, dma_handle, ((( gfp_t)0x20u)|(( gfp_t)0x200u)|(( gfp_t)0x800u)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *
>pci_zalloc_consistent(struct pci_dev *hwdev, size_t size,
>        dma_addr_t *dma_handle)
>{
> return dma_alloc_coherent(&hwdev->dev, size, dma_handle, ((( gfp_t)0x20u)|(( gfp_t)0x200u)|(( gfp_t)0x800u)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_free_consistent(struct pci_dev *hwdev, size_t size,
>      void *vaddr, dma_addr_t dma_handle)
>{
> dma_free_coherent(&hwdev->dev, size, vaddr, dma_handle);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dma_addr_t
>pci_map_single(struct pci_dev *hwdev, void *ptr, size_t size, int direction)
>{
> return dma_map_single_attrs(&hwdev->dev, ptr, size, (enum dma_data_direction)direction, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_unmap_single(struct pci_dev *hwdev, dma_addr_t dma_addr,
>   size_t size, int direction)
>{
> dma_unmap_single_attrs(&hwdev->dev, dma_addr, size, (enum dma_data_direction)direction, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dma_addr_t
>pci_map_page(struct pci_dev *hwdev, struct page *page,
>      unsigned long offset, size_t size, int direction)
>{
> return dma_map_page_attrs(&hwdev->dev, page, offset, size, (enum dma_data_direction)direction, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_unmap_page(struct pci_dev *hwdev, dma_addr_t dma_address,
>        size_t size, int direction)
>{
> dma_unmap_page_attrs(&hwdev->dev, dma_address, size, (enum dma_data_direction)direction, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>pci_map_sg(struct pci_dev *hwdev, struct scatterlist *sg,
>    int nents, int direction)
>{
> return dma_map_sg_attrs(&hwdev->dev, sg, nents, (enum dma_data_direction)direction, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_unmap_sg(struct pci_dev *hwdev, struct scatterlist *sg,
>      int nents, int direction)
>{
> dma_unmap_sg_attrs(&hwdev->dev, sg, nents, (enum dma_data_direction)direction, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_dma_sync_single_for_cpu(struct pci_dev *hwdev, dma_addr_t dma_handle,
>      size_t size, int direction)
>{
> dma_sync_single_for_cpu(&hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_dma_sync_single_for_device(struct pci_dev *hwdev, dma_addr_t dma_handle,
>      size_t size, int direction)
>{
> dma_sync_single_for_device(&hwdev->dev, dma_handle, size, (enum dma_data_direction)direction);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_dma_sync_sg_for_cpu(struct pci_dev *hwdev, struct scatterlist *sg,
>  int nelems, int direction)
>{
> dma_sync_sg_for_cpu(&hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pci_dma_sync_sg_for_device(struct pci_dev *hwdev, struct scatterlist *sg,
>  int nelems, int direction)
>{
> dma_sync_sg_for_device(&hwdev->dev, sg, nelems, (enum dma_data_direction)direction);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>pci_dma_mapping_error(struct pci_dev *pdev, dma_addr_t dma_addr)
>{
> return dma_mapping_error(&pdev->dev, dma_addr);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_set_dma_mask(struct pci_dev *dev, u64 mask)
>{
> return dma_set_mask(&dev->dev, mask);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pci_set_consistent_dma_mask(struct pci_dev *dev, u64 mask)
>{
> return dma_set_coherent_mask(&dev->dev, mask);
>}
># 2562 "/usr/src/linux-5.14.21-150500.53/include/linux/pci.h" 2
># 120 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/file.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/file.h"
>struct file;
>
>extern void fput(struct file *);
>extern void fput_many(struct file *, unsigned int);
>
>struct file_operations;
>struct task_struct;
>struct vfsmount;
>struct dentry;
>struct inode;
>struct path;
>extern struct file *alloc_file_pseudo(struct inode *, struct vfsmount *,
> const char *, int flags, const struct file_operations *);
>extern struct file *alloc_file_clone(struct file *, int flags,
> const struct file_operations *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fput_light(struct file *file, int fput_needed)
>{
> if (fput_needed)
>  fput(file);
>}
>
>struct fd {
> struct file *file;
> unsigned int flags;
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fdput(struct fd fd)
>{
> if (fd.flags & 1)
>  fput(fd.file);
>}
>
>extern struct file *fget(unsigned int fd);
>extern struct file *fget_many(unsigned int fd, unsigned int refs);
>extern struct file *fget_raw(unsigned int fd);
>extern struct file *fget_task(struct task_struct *task, unsigned int fd);
>extern unsigned long __fdget(unsigned int fd);
>extern unsigned long __fdget_raw(unsigned int fd);
>extern unsigned long __fdget_pos(unsigned int fd);
>extern void __f_unlock_pos(struct file *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fd __to_fd(unsigned long v)
>{
> return (struct fd){(struct file *)(v & ~3),v & 3};
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fd fdget(unsigned int fd)
>{
> return __to_fd(__fdget(fd));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fd fdget_raw(unsigned int fd)
>{
> return __to_fd(__fdget_raw(fd));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fd fdget_pos(int fd)
>{
> return __to_fd(__fdget_pos(fd));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void fdput_pos(struct fd f)
>{
> if (f.flags & 2)
>  __f_unlock_pos(f.file);
> fdput(f);
>}
>
>extern int f_dupfd(unsigned int from, struct file *file, unsigned flags);
>extern int replace_fd(unsigned fd, struct file *file, unsigned flags);
>extern void set_close_on_exec(unsigned int fd, int flag);
>extern bool get_close_on_exec(unsigned int fd);
>extern int __get_unused_fd_flags(unsigned flags, unsigned long nofile);
>extern int get_unused_fd_flags(unsigned flags);
>extern void put_unused_fd(unsigned int fd);
>
>extern void fd_install(unsigned int fd, struct file *file);
>
>extern int __receive_fd(struct file *file, int *ufd,
>   unsigned int o_flags);
>
>extern int receive_fd(struct file *file, unsigned int o_flags);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int receive_fd_user(struct file *file, int *ufd,
>      unsigned int o_flags)
>{
> if (ufd == ((void *)0))
>  return -14;
> return __receive_fd(file, ufd, o_flags);
>}
>int receive_fd_replace(int new_fd, struct file *file, unsigned int o_flags);
>
>extern void flush_delayed_fput(void);
>extern void __fput_sync(struct file *);
>
>extern unsigned int sysctl_nr_open_min, sysctl_nr_open_max;
># 123 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/node.h" 1
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/node.h"
>struct node_hmem_attrs {
> unsigned int read_bandwidth;
> unsigned int write_bandwidth;
> unsigned int read_latency;
> unsigned int write_latency;
>};
>
>enum cache_indexing {
> NODE_CACHE_DIRECT_MAP,
> NODE_CACHE_INDEXED,
> NODE_CACHE_OTHER,
>};
>
>enum cache_write_policy {
> NODE_CACHE_WRITE_BACK,
> NODE_CACHE_WRITE_THROUGH,
> NODE_CACHE_WRITE_OTHER,
>};
># 59 "/usr/src/linux-5.14.21-150500.53/include/linux/node.h"
>struct node_cache_attrs {
> enum cache_indexing indexing;
> enum cache_write_policy write_policy;
> u64 size;
> u16 line_size;
> u8 level;
>};
>
>
>void node_add_cache(unsigned int nid, struct node_cache_attrs *cache_attrs);
>void node_set_perf_attrs(unsigned int nid, struct node_hmem_attrs *hmem_attrs,
>    unsigned access);
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/node.h"
>struct node {
> struct device dev;
> struct list_head access_list;
>
>
> struct work_struct node_work;
>
>
> struct list_head cache_attrs;
> struct device *cache_dev;
>
>};
>
>struct memory_block;
>extern struct node *node_devices[];
>typedef void (*node_registration_func_t)(struct node *);
>
>
>void link_mem_sections(int nid, unsigned long start_pfn,
>         unsigned long end_pfn,
>         enum meminit_context context);
># 113 "/usr/src/linux-5.14.21-150500.53/include/linux/node.h"
>extern void unregister_node(struct node *node);
>
>
>extern int __register_one_node(int nid);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int register_one_node(int nid)
>{
> int error = 0;
>
> if (node_state((nid), N_ONLINE)) {
>  struct pglist_data *pgdat = (node_data[nid]);
>  unsigned long start_pfn = pgdat->node_start_pfn;
>  unsigned long end_pfn = start_pfn + pgdat->node_spanned_pages;
>
>  error = __register_one_node(nid);
>  if (error)
>   return error;
>
>  link_mem_sections(nid, start_pfn, end_pfn, MEMINIT_EARLY);
> }
>
> return error;
>}
>
>extern void unregister_one_node(int nid);
>extern int register_cpu_under_node(unsigned int cpu, unsigned int nid);
>extern int unregister_cpu_under_node(unsigned int cpu, unsigned int nid);
>extern void unregister_memory_block_under_nodes(struct memory_block *mem_blk);
>
>extern int register_memory_node_under_compute_node(unsigned int mem_nid,
>         unsigned int cpu_nid,
>         unsigned access);
>
>
>extern void register_hugetlbfs_with_node(node_registration_func_t doregister,
>      node_registration_func_t unregister);
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h" 1
># 57 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>enum cpuhp_state {
> CPUHP_INVALID = -1,
>
>
> CPUHP_OFFLINE = 0,
> CPUHP_CREATE_THREADS,
> CPUHP_PERF_PREPARE,
> CPUHP_PERF_X86_PREPARE,
> CPUHP_PERF_X86_AMD_UNCORE_PREP,
> CPUHP_PERF_POWER,
> CPUHP_PERF_SUPERH,
> CPUHP_X86_HPET_DEAD,
> CPUHP_X86_APB_DEAD,
> CPUHP_X86_MCE_DEAD,
> CPUHP_VIRT_NET_DEAD,
> CPUHP_IBMVNIC_DEAD,
> CPUHP_SLUB_DEAD,
> CPUHP_DEBUG_OBJ_DEAD,
> CPUHP_MM_WRITEBACK_DEAD,
>
> CPUHP_MM_DEMOTION_DEAD,
> CPUHP_MM_VMSTAT_DEAD,
> CPUHP_SOFTIRQ_DEAD,
> CPUHP_NET_MVNETA_DEAD,
> CPUHP_CPUIDLE_DEAD,
> CPUHP_ARM64_FPSIMD_DEAD,
> CPUHP_ARM_OMAP_WAKE_DEAD,
> CPUHP_IRQ_POLL_DEAD,
> CPUHP_BLOCK_SOFTIRQ_DEAD,
> CPUHP_BIO_DEAD,
> CPUHP_ACPI_CPUDRV_DEAD,
> CPUHP_S390_PFAULT_DEAD,
> CPUHP_BLK_MQ_DEAD,
> CPUHP_FS_BUFF_DEAD,
> CPUHP_PRINTK_DEAD,
> CPUHP_MM_MEMCQ_DEAD,
> CPUHP_PERCPU_CNT_DEAD,
> CPUHP_RADIX_DEAD,
> CPUHP_PAGE_ALLOC,
> CPUHP_NET_DEV_DEAD,
> CPUHP_PCI_XGENE_DEAD,
> CPUHP_IOMMU_IOVA_DEAD,
> CPUHP_LUSTRE_CFS_DEAD,
> CPUHP_AP_ARM_CACHE_B15_RAC_DEAD,
> CPUHP_PADATA_DEAD,
> CPUHP_WORKQUEUE_PREP,
> CPUHP_POWER_NUMA_PREPARE,
> CPUHP_HRTIMERS_PREPARE,
> CPUHP_PROFILE_PREPARE,
> CPUHP_X2APIC_PREPARE,
> CPUHP_SMPCFD_PREPARE,
> CPUHP_RELAY_PREPARE,
> CPUHP_SLAB_PREPARE,
> CPUHP_MD_RAID5_PREPARE,
> CPUHP_RCUTREE_PREP,
> CPUHP_CPUIDLE_COUPLED_PREPARE,
> CPUHP_POWERPC_PMAC_PREPARE,
> CPUHP_POWERPC_MMU_CTX_PREPARE,
> CPUHP_XEN_PREPARE,
> CPUHP_XEN_EVTCHN_PREPARE,
> CPUHP_ARM_SHMOBILE_SCU_PREPARE,
> CPUHP_SH_SH3X_PREPARE,
> CPUHP_NET_FLOW_PREPARE,
> CPUHP_TOPOLOGY_PREPARE,
> CPUHP_NET_IUCV_PREPARE,
> CPUHP_ARM_BL_PREPARE,
> CPUHP_TRACE_RB_PREPARE,
> CPUHP_MM_ZS_PREPARE,
> CPUHP_MM_ZSWP_MEM_PREPARE,
> CPUHP_MM_ZSWP_POOL_PREPARE,
> CPUHP_KVM_PPC_BOOK3S_PREPARE,
> CPUHP_ZCOMP_PREPARE,
> CPUHP_TIMERS_PREPARE,
> CPUHP_MIPS_SOC_PREPARE,
> CPUHP_BP_PREPARE_DYN,
> CPUHP_BP_PREPARE_DYN_END = CPUHP_BP_PREPARE_DYN + 20,
> CPUHP_BRINGUP_CPU,
>
>
>
>
>
> CPUHP_AP_IDLE_DEAD,
> CPUHP_AP_OFFLINE,
> CPUHP_AP_SCHED_STARTING,
> CPUHP_AP_RCUTREE_DYING,
> CPUHP_AP_CPU_PM_STARTING,
> CPUHP_AP_IRQ_GIC_STARTING,
> CPUHP_AP_IRQ_HIP04_STARTING,
> CPUHP_AP_IRQ_APPLE_AIC_STARTING,
> CPUHP_AP_IRQ_ARMADA_XP_STARTING,
> CPUHP_AP_IRQ_BCM2836_STARTING,
> CPUHP_AP_IRQ_MIPS_GIC_STARTING,
> CPUHP_AP_IRQ_RISCV_STARTING,
> CPUHP_AP_IRQ_SIFIVE_PLIC_STARTING,
> CPUHP_AP_ARM_MVEBU_COHERENCY,
> CPUHP_AP_MICROCODE_LOADER,
> CPUHP_AP_PERF_X86_AMD_UNCORE_STARTING,
> CPUHP_AP_PERF_X86_STARTING,
> CPUHP_AP_PERF_X86_AMD_IBS_STARTING,
> CPUHP_AP_PERF_X86_CQM_STARTING,
> CPUHP_AP_PERF_X86_CSTATE_STARTING,
> CPUHP_AP_PERF_XTENSA_STARTING,
> CPUHP_AP_MIPS_OP_LOONGSON3_STARTING,
> CPUHP_AP_ARM_SDEI_STARTING,
> CPUHP_AP_ARM_VFP_STARTING,
> CPUHP_AP_ARM64_DEBUG_MONITORS_STARTING,
> CPUHP_AP_PERF_ARM_HW_BREAKPOINT_STARTING,
> CPUHP_AP_PERF_ARM_ACPI_STARTING,
> CPUHP_AP_PERF_ARM_STARTING,
> CPUHP_AP_ARM_L2X0_STARTING,
> CPUHP_AP_EXYNOS4_MCT_TIMER_STARTING,
> CPUHP_AP_ARM_ARCH_TIMER_STARTING,
> CPUHP_AP_ARM_GLOBAL_TIMER_STARTING,
> CPUHP_AP_JCORE_TIMER_STARTING,
> CPUHP_AP_ARM_TWD_STARTING,
> CPUHP_AP_QCOM_TIMER_STARTING,
> CPUHP_AP_TEGRA_TIMER_STARTING,
> CPUHP_AP_ARMADA_TIMER_STARTING,
> CPUHP_AP_MARCO_TIMER_STARTING,
> CPUHP_AP_MIPS_GIC_TIMER_STARTING,
> CPUHP_AP_ARC_TIMER_STARTING,
> CPUHP_AP_RISCV_TIMER_STARTING,
> CPUHP_AP_CLINT_TIMER_STARTING,
> CPUHP_AP_CSKY_TIMER_STARTING,
> CPUHP_AP_TI_GP_TIMER_STARTING,
> CPUHP_AP_HYPERV_TIMER_STARTING,
> CPUHP_AP_KVM_STARTING,
> CPUHP_AP_KVM_ARM_VGIC_INIT_STARTING,
> CPUHP_AP_KVM_ARM_VGIC_STARTING,
> CPUHP_AP_KVM_ARM_TIMER_STARTING,
>
> CPUHP_AP_DUMMY_TIMER_STARTING,
> CPUHP_AP_ARM_XEN_STARTING,
> CPUHP_AP_ARM_CORESIGHT_STARTING,
> CPUHP_AP_ARM_CORESIGHT_CTI_STARTING,
> CPUHP_AP_ARM64_ISNDEP_STARTING,
> CPUHP_AP_SMPCFD_DYING,
> CPUHP_AP_X86_TBOOT_DYING,
> CPUHP_AP_ARM_CACHE_B15_RAC_DYING,
> CPUHP_AP_ONLINE,
> CPUHP_TEARDOWN_CPU,
>
>
> CPUHP_AP_ONLINE_IDLE,
> CPUHP_AP_SCHED_WAIT_EMPTY,
> CPUHP_AP_SMPBOOT_THREADS,
> CPUHP_AP_X86_VDSO_VMA_ONLINE,
> CPUHP_AP_IRQ_AFFINITY_ONLINE,
> CPUHP_AP_BLK_MQ_ONLINE,
> CPUHP_AP_ARM_MVEBU_SYNC_CLOCKS,
> CPUHP_AP_X86_INTEL_EPB_ONLINE,
> CPUHP_AP_PERF_ONLINE,
> CPUHP_AP_PERF_X86_ONLINE,
> CPUHP_AP_PERF_X86_UNCORE_ONLINE,
> CPUHP_AP_PERF_X86_AMD_UNCORE_ONLINE,
> CPUHP_AP_PERF_X86_AMD_POWER_ONLINE,
> CPUHP_AP_PERF_X86_RAPL_ONLINE,
> CPUHP_AP_PERF_X86_CQM_ONLINE,
> CPUHP_AP_PERF_X86_CSTATE_ONLINE,
> CPUHP_AP_PERF_X86_IDXD_ONLINE,
> CPUHP_AP_PERF_S390_CF_ONLINE,
> CPUHP_AP_PERF_S390_SF_ONLINE,
> CPUHP_AP_PERF_ARM_CCI_ONLINE,
> CPUHP_AP_PERF_ARM_CCN_ONLINE,
> CPUHP_AP_PERF_ARM_HISI_DDRC_ONLINE,
> CPUHP_AP_PERF_ARM_HISI_HHA_ONLINE,
> CPUHP_AP_PERF_ARM_HISI_L3_ONLINE,
> CPUHP_AP_PERF_ARM_HISI_PA_ONLINE,
> CPUHP_AP_PERF_ARM_HISI_SLLC_ONLINE,
> CPUHP_AP_PERF_ARM_HNS3_PMU_ONLINE,
> CPUHP_AP_PERF_ARM_L2X0_ONLINE,
> CPUHP_AP_PERF_ARM_QCOM_L2_ONLINE,
> CPUHP_AP_PERF_ARM_QCOM_L3_ONLINE,
> CPUHP_AP_PERF_ARM_APM_XGENE_ONLINE,
> CPUHP_AP_PERF_ARM_CAVIUM_TX2_UNCORE_ONLINE,
> CPUHP_AP_PERF_ARM_MARVELL_CN10K_DDR_ONLINE,
> CPUHP_AP_PERF_POWERPC_NEST_IMC_ONLINE,
> CPUHP_AP_PERF_POWERPC_CORE_IMC_ONLINE,
> CPUHP_AP_PERF_POWERPC_THREAD_IMC_ONLINE,
> CPUHP_AP_PERF_POWERPC_TRACE_IMC_ONLINE,
> CPUHP_AP_PERF_POWERPC_HV_24x7_ONLINE,
> CPUHP_AP_PERF_POWERPC_HV_GPCI_ONLINE,
> CPUHP_AP_PERF_CSKY_ONLINE,
> CPUHP_AP_WATCHDOG_ONLINE,
> CPUHP_AP_WORKQUEUE_ONLINE,
> CPUHP_AP_RCUTREE_ONLINE,
> CPUHP_AP_BASE_CACHEINFO_ONLINE,
> CPUHP_AP_ONLINE_DYN,
> CPUHP_AP_ONLINE_DYN_END = CPUHP_AP_ONLINE_DYN + 30,
>
> CPUHP_AP_MM_DEMOTION_ONLINE,
> CPUHP_AP_X86_HPET_ONLINE,
> CPUHP_AP_X86_KVM_CLK_ONLINE,
> CPUHP_AP_DTPM_CPU_ONLINE,
> CPUHP_AP_ACTIVE,
> CPUHP_ONLINE,
>};
>
>int __cpuhp_setup_state(enum cpuhp_state state, const char *name, bool invoke,
>   int (*startup)(unsigned int cpu),
>   int (*teardown)(unsigned int cpu), bool multi_instance);
>
>int __cpuhp_setup_state_cpuslocked(enum cpuhp_state state, const char *name,
>       bool invoke,
>       int (*startup)(unsigned int cpu),
>       int (*teardown)(unsigned int cpu),
>       bool multi_instance);
># 276 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_setup_state(enum cpuhp_state state,
>        const char *name,
>        int (*startup)(unsigned int cpu),
>        int (*teardown)(unsigned int cpu))
>{
> return __cpuhp_setup_state(state, name, true, startup, teardown, false);
>}
># 296 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_setup_state_cpuslocked(enum cpuhp_state state,
>            const char *name,
>            int (*startup)(unsigned int cpu),
>            int (*teardown)(unsigned int cpu))
>{
> return __cpuhp_setup_state_cpuslocked(state, name, true, startup,
>           teardown, false);
>}
># 316 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_setup_state_nocalls(enum cpuhp_state state,
>         const char *name,
>         int (*startup)(unsigned int cpu),
>         int (*teardown)(unsigned int cpu))
>{
> return __cpuhp_setup_state(state, name, false, startup, teardown,
>       false);
>}
># 338 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_setup_state_nocalls_cpuslocked(enum cpuhp_state state,
>           const char *name,
>           int (*startup)(unsigned int cpu),
>           int (*teardown)(unsigned int cpu))
>{
> return __cpuhp_setup_state_cpuslocked(state, name, false, startup,
>         teardown, false);
>}
># 359 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_setup_state_multi(enum cpuhp_state state,
>       const char *name,
>       int (*startup)(unsigned int cpu,
>        struct hlist_node *node),
>       int (*teardown)(unsigned int cpu,
>         struct hlist_node *node))
>{
> return __cpuhp_setup_state(state, name, false,
>       (void *) startup,
>       (void *) teardown, true);
>}
>
>int __cpuhp_state_add_instance(enum cpuhp_state state, struct hlist_node *node,
>          bool invoke);
>int __cpuhp_state_add_instance_cpuslocked(enum cpuhp_state state,
>       struct hlist_node *node, bool invoke);
># 387 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_state_add_instance(enum cpuhp_state state,
>        struct hlist_node *node)
>{
> return __cpuhp_state_add_instance(state, node, true);
>}
># 403 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_state_add_instance_nocalls(enum cpuhp_state state,
>         struct hlist_node *node)
>{
> return __cpuhp_state_add_instance(state, node, false);
>}
># 420 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>cpuhp_state_add_instance_nocalls_cpuslocked(enum cpuhp_state state,
>         struct hlist_node *node)
>{
> return __cpuhp_state_add_instance_cpuslocked(state, node, false);
>}
>
>void __cpuhp_remove_state(enum cpuhp_state state, bool invoke);
>void __cpuhp_remove_state_cpuslocked(enum cpuhp_state state, bool invoke);
># 437 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpuhp_remove_state(enum cpuhp_state state)
>{
> __cpuhp_remove_state(state, true);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpuhp_remove_state_nocalls(enum cpuhp_state state)
>{
> __cpuhp_remove_state(state, false);
>}
># 460 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpuhp_remove_state_nocalls_cpuslocked(enum cpuhp_state state)
>{
> __cpuhp_remove_state_cpuslocked(state, false);
>}
># 473 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpuhp_remove_multi_state(enum cpuhp_state state)
>{
> __cpuhp_remove_state(state, false);
>}
>
>int __cpuhp_state_remove_instance(enum cpuhp_state state,
>      struct hlist_node *node, bool invoke);
># 490 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_state_remove_instance(enum cpuhp_state state,
>           struct hlist_node *node)
>{
> return __cpuhp_state_remove_instance(state, node, true);
>}
># 504 "/usr/src/linux-5.14.21-150500.53/include/linux/cpuhotplug.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cpuhp_state_remove_instance_nocalls(enum cpuhp_state state,
>            struct hlist_node *node)
>{
> return __cpuhp_state_remove_instance(state, node, false);
>}
>
>
>void cpuhp_online_idle(enum cpuhp_state state);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h" 2
>
>struct device;
>struct device_node;
>struct attribute_group;
>
>struct cpu {
> int node_id;
> int hotpluggable;
> struct device dev;
>};
>
>extern void boot_cpu_init(void);
>extern void boot_cpu_hotplug_init(void);
>extern void cpu_init(void);
>extern void trap_init(void);
>
>extern int register_cpu(struct cpu *cpu, int num);
>extern struct device *get_cpu_device(unsigned cpu);
>extern bool cpu_is_hotpluggable(unsigned cpu);
>extern bool arch_match_cpu_phys_id(int cpu, u64 phys_id);
>extern bool arch_find_n_match_cpu_physical_id(struct device_node *cpun,
>           int cpu, unsigned int *thread);
>
>extern int cpu_add_dev_attr(struct device_attribute *attr);
>extern void cpu_remove_dev_attr(struct device_attribute *attr);
>
>extern int cpu_add_dev_attr_group(struct attribute_group *attrs);
>extern void cpu_remove_dev_attr_group(struct attribute_group *attrs);
>
>extern ssize_t cpu_show_meltdown(struct device *dev,
>     struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_spectre_v1(struct device *dev,
>       struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_spectre_v2(struct device *dev,
>       struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_spec_store_bypass(struct device *dev,
>       struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_l1tf(struct device *dev,
>        struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_mds(struct device *dev,
>       struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_tsx_async_abort(struct device *dev,
>     struct device_attribute *attr,
>     char *buf);
>extern ssize_t cpu_show_itlb_multihit(struct device *dev,
>          struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_srbds(struct device *dev, struct device_attribute *attr, char *buf);
>extern ssize_t cpu_show_mmio_stale_data(struct device *dev,
>     struct device_attribute *attr,
>     char *buf);
>extern ssize_t cpu_show_retbleed(struct device *dev,
>     struct device_attribute *attr, char *buf);
>
>extern __attribute__((__format__(printf, 4, 5)))
>struct device *cpu_device_create(struct device *parent, void *drvdata,
>     const struct attribute_group **groups,
>     const char *fmt, ...);
>
>extern void unregister_cpu(struct cpu *cpu);
>extern ssize_t arch_cpu_probe(const char *, size_t);
>extern ssize_t arch_cpu_release(const char *, size_t);
># 96 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h"
>extern bool cpuhp_tasks_frozen;
>int add_cpu(unsigned int cpu);
>int cpu_device_up(struct device *dev);
>void notify_cpu_starting(unsigned int cpu);
>extern void cpu_maps_update_begin(void);
>extern void cpu_maps_update_done(void);
>int bringup_hibernate_cpu(unsigned int sleep_cpu);
>void bringup_nonboot_cpus(unsigned int setup_max_cpus);
># 119 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h"
>extern struct bus_type cpu_subsys;
>
>extern int lockdep_is_cpus_held(void);
>
>
>extern void cpus_write_lock(void);
>extern void cpus_write_unlock(void);
>extern void cpus_read_lock(void);
>extern void cpus_read_unlock(void);
>extern int cpus_read_trylock(void);
>extern void lockdep_assert_cpus_held(void);
>extern void cpu_hotplug_disable(void);
>extern void cpu_hotplug_enable(void);
>void clear_tasks_mm_cpumask(int cpu);
>int remove_cpu(unsigned int cpu);
>int cpu_device_down(struct device *dev);
>extern void smp_shutdown_nonboot_cpus(unsigned int primary_cpu);
># 152 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpu_hotplug_begin(void) { cpus_write_lock(); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cpu_hotplug_done(void) { cpus_write_unlock(); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void get_online_cpus(void) { cpus_read_lock(); }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_online_cpus(void) { cpus_read_unlock(); }
>
>
>extern int freeze_secondary_cpus(int primary);
>extern void thaw_secondary_cpus(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int suspend_disable_secondary_cpus(void)
>{
> int cpu = 0;
>
> if (0)
>  cpu = -1;
>
> return freeze_secondary_cpus(cpu);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void suspend_enable_secondary_cpus(void)
>{
> return thaw_secondary_cpus();
>}
>
>
>
>
>
>
>
>void cpu_startup_entry(enum cpuhp_state state);
>
>void cpu_idle_poll_ctrl(bool enable);
>
>
>
>
>bool cpu_in_idle(unsigned long pc);
>
>void arch_cpu_idle(void);
>void arch_cpu_idle_prepare(void);
>void arch_cpu_idle_enter(void);
>void arch_cpu_idle_exit(void);
>void arch_cpu_idle_dead(void);
>
>int cpu_report_state(int cpu);
>int cpu_check_up_prepare(int cpu);
>void cpu_set_state_online(int cpu);
>void play_idle_precise(u64 duration_ns, u64 latency_ns);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void play_idle(unsigned long duration_us)
>{
> play_idle_precise(duration_us * 1000L, ((u64)~0ULL));
>}
>
>
>bool cpu_wait_death(unsigned int cpu, int seconds);
>bool cpu_report_death(void);
>void cpuhp_report_idle_dead(void);
>
>
>
>
>enum cpuhp_smt_control {
> CPU_SMT_ENABLED,
> CPU_SMT_DISABLED,
> CPU_SMT_FORCE_DISABLED,
> CPU_SMT_NOT_SUPPORTED,
> CPU_SMT_NOT_IMPLEMENTED,
>};
>
>
>extern enum cpuhp_smt_control cpu_smt_control;
>extern void cpu_smt_disable(bool force);
>extern void cpu_smt_check_topology(void);
>extern bool cpu_smt_possible(void);
>extern int cpuhp_smt_enable(void);
>extern int cpuhp_smt_disable(enum cpuhp_smt_control ctrlval);
># 238 "/usr/src/linux-5.14.21-150500.53/include/linux/cpu.h"
>extern bool cpu_mitigations_off(void);
>extern bool cpu_mitigations_auto_nosmt(void);
># 125 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 135 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-list-helpers.h" 1
># 136 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 172 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/vgaarb.h" 1
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/vgaarb.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/video/vga.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/video/vga.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vga.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vga.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/set_memory.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/set_memory.h" 1
>
>
>
>
>
>
>
>int set_memory_ro(unsigned long addr, int numpages);
>int set_memory_rw(unsigned long addr, int numpages);
>int set_memory_x(unsigned long addr, int numpages);
>int set_memory_nx(unsigned long addr, int numpages);
># 7 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/set_memory.h" 2
># 37 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/set_memory.h"
>int __set_memory_prot(unsigned long addr, int numpages, pgprot_t prot);
>int _set_memory_uc(unsigned long addr, int numpages);
>int _set_memory_wc(unsigned long addr, int numpages);
>int _set_memory_wt(unsigned long addr, int numpages);
>int _set_memory_wb(unsigned long addr, int numpages);
>int set_memory_uc(unsigned long addr, int numpages);
>int set_memory_wc(unsigned long addr, int numpages);
>int set_memory_wb(unsigned long addr, int numpages);
>int set_memory_np(unsigned long addr, int numpages);
>int set_memory_4k(unsigned long addr, int numpages);
>int set_memory_encrypted(unsigned long addr, int numpages);
>int set_memory_decrypted(unsigned long addr, int numpages);
>int set_memory_np_noalias(unsigned long addr, int numpages);
>int set_memory_nonglobal(unsigned long addr, int numpages);
>int set_memory_global(unsigned long addr, int numpages);
>
>int set_pages_array_uc(struct page **pages, int addrinarray);
>int set_pages_array_wc(struct page **pages, int addrinarray);
>int set_pages_array_wt(struct page **pages, int addrinarray);
>int set_pages_array_wb(struct page **pages, int addrinarray);
># 78 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/set_memory.h"
>int set_pages_uc(struct page *page, int numpages);
>int set_pages_wb(struct page *page, int numpages);
>int set_pages_ro(struct page *page, int numpages);
>int set_pages_rw(struct page *page, int numpages);
>
>int set_direct_map_invalid_noflush(struct page *page);
>int set_direct_map_default_noflush(struct page *page);
>bool kernel_page_present(struct page *page);
>
>extern int kernel_set_to_readonly;
># 96 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/set_memory.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int set_mce_nospec(unsigned long pfn, bool unmap)
>{
> unsigned long decoy_addr;
> int rc;
># 113 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/set_memory.h"
> decoy_addr = (pfn << 12) + (((unsigned long)page_offset_base) ^ ((((1UL))) << (63)));
>
> if (unmap)
>  rc = set_memory_np(decoy_addr, 1);
> else
>  rc = set_memory_uc(decoy_addr, 1);
> if (rc)
>  printk("\001" "4" "Could not invalidate pfn=0x%lx from 1:1 map\n", pfn);
> return rc;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int clear_mce_nospec(unsigned long pfn)
>{
> return set_memory_wb((unsigned long) ((void *)((unsigned long)((pfn) << 12)+((unsigned long)page_offset_base))), 1);
>}
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/vga.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/include/video/vga.h" 2
># 182 "/usr/src/linux-5.14.21-150500.53/include/video/vga.h"
>struct vgastate {
> void *vgabase;
> unsigned long membase;
> __u32 memsize;
> __u32 flags;
> __u32 depth;
> __u32 num_attr;
> __u32 num_crtc;
> __u32 num_gfx;
> __u32 num_seq;
> void *vidstate;
>};
>
>extern int save_vga(struct vgastate *state);
>extern int restore_vga(struct vgastate *state);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_io_r (unsigned short port)
>{
> return inb_p(port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_io_w (unsigned short port, unsigned char val)
>{
> outb_p(val, port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_io_w_fast (unsigned short port, unsigned char reg,
>      unsigned char val)
>{
> __outw((((val) << 8) | (reg)), port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_mm_r (void *regbase, unsigned short port)
>{
> return readb (regbase + port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_mm_w (void *regbase, unsigned short port, unsigned char val)
>{
> writeb (val, regbase + port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_mm_w_fast (void *regbase, unsigned short port,
>      unsigned char reg, unsigned char val)
>{
> writew ((((val) << 8) | (reg)), regbase + port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_r (void *regbase, unsigned short port)
>{
> if (regbase)
>  return vga_mm_r (regbase, port);
> else
>  return vga_io_r (port);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_w (void *regbase, unsigned short port, unsigned char val)
>{
> if (regbase)
>  vga_mm_w (regbase, port, val);
> else
>  vga_io_w (port, val);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_w_fast (void *regbase, unsigned short port,
>          unsigned char reg, unsigned char val)
>{
> if (regbase)
>  vga_mm_w_fast (regbase, port, reg, val);
> else
>  vga_io_w_fast (port, reg, val);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_rcrt (void *regbase, unsigned char reg)
>{
>        vga_w (regbase, 0x3D4, reg);
>        return vga_r (regbase, 0x3D5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_wcrt (void *regbase, unsigned char reg, unsigned char val)
>{
>
> vga_w_fast (regbase, 0x3D4, reg, val);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_io_rcrt (unsigned char reg)
>{
>        vga_io_w (0x3D4, reg);
>        return vga_io_r (0x3D5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_io_wcrt (unsigned char reg, unsigned char val)
>{
>
> vga_io_w_fast (0x3D4, reg, val);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_mm_rcrt (void *regbase, unsigned char reg)
>{
>        vga_mm_w (regbase, 0x3D4, reg);
>        return vga_mm_r (regbase, 0x3D5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_mm_wcrt (void *regbase, unsigned char reg, unsigned char val)
>{
>
> vga_mm_w_fast (regbase, 0x3D4, reg, val);
>
>
>
>
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_rseq (void *regbase, unsigned char reg)
>{
>        vga_w (regbase, 0x3C4, reg);
>        return vga_r (regbase, 0x3C5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_wseq (void *regbase, unsigned char reg, unsigned char val)
>{
>
> vga_w_fast (regbase, 0x3C4, reg, val);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_io_rseq (unsigned char reg)
>{
>        vga_io_w (0x3C4, reg);
>        return vga_io_r (0x3C5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_io_wseq (unsigned char reg, unsigned char val)
>{
>
> vga_io_w_fast (0x3C4, reg, val);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_mm_rseq (void *regbase, unsigned char reg)
>{
>        vga_mm_w (regbase, 0x3C4, reg);
>        return vga_mm_r (regbase, 0x3C5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_mm_wseq (void *regbase, unsigned char reg, unsigned char val)
>{
>
> vga_mm_w_fast (regbase, 0x3C4, reg, val);
>
>
>
>
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_rgfx (void *regbase, unsigned char reg)
>{
>        vga_w (regbase, 0x3CE, reg);
>        return vga_r (regbase, 0x3CF);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_wgfx (void *regbase, unsigned char reg, unsigned char val)
>{
>
> vga_w_fast (regbase, 0x3CE, reg, val);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_io_rgfx (unsigned char reg)
>{
>        vga_io_w (0x3CE, reg);
>        return vga_io_r (0x3CF);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_io_wgfx (unsigned char reg, unsigned char val)
>{
>
> vga_io_w_fast (0x3CE, reg, val);
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_mm_rgfx (void *regbase, unsigned char reg)
>{
>        vga_mm_w (regbase, 0x3CE, reg);
>        return vga_mm_r (regbase, 0x3CF);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_mm_wgfx (void *regbase, unsigned char reg, unsigned char val)
>{
>
> vga_mm_w_fast (regbase, 0x3CE, reg, val);
>
>
>
>
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_rattr (void *regbase, unsigned char reg)
>{
>        vga_w (regbase, 0x3C0, reg);
>        return vga_r (regbase, 0x3C1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_wattr (void *regbase, unsigned char reg, unsigned char val)
>{
>        vga_w (regbase, 0x3C0, reg);
>        vga_w (regbase, 0x3C0, val);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_io_rattr (unsigned char reg)
>{
>        vga_io_w (0x3C0, reg);
>        return vga_io_r (0x3C1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_io_wattr (unsigned char reg, unsigned char val)
>{
>        vga_io_w (0x3C0, reg);
>        vga_io_w (0x3C0, val);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char vga_mm_rattr (void *regbase, unsigned char reg)
>{
>        vga_mm_w (regbase, 0x3C0, reg);
>        return vga_mm_r (regbase, 0x3C1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_mm_wattr (void *regbase, unsigned char reg, unsigned char val)
>{
>        vga_mm_w (regbase, 0x3C0, reg);
>        vga_mm_w (regbase, 0x3C0, val);
>}
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/vgaarb.h" 2
>
>struct pci_dev;
># 48 "/usr/src/linux-5.14.21-150500.53/include/linux/vgaarb.h"
>void vga_set_legacy_decoding(struct pci_dev *pdev, unsigned int decodes);
>int vga_get(struct pci_dev *pdev, unsigned int rsrc, int interruptible);
>void vga_put(struct pci_dev *pdev, unsigned int rsrc);
>struct pci_dev *vga_default_device(void);
>void vga_set_default_device(struct pci_dev *pdev);
>int vga_remove_vgacon(struct pci_dev *pdev);
>int vga_client_register(struct pci_dev *pdev,
>  unsigned int (*set_decode)(struct pci_dev *pdev, bool state));
># 96 "/usr/src/linux-5.14.21-150500.53/include/linux/vgaarb.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vga_get_interruptible(struct pci_dev *pdev,
>     unsigned int rsrc)
>{
>       return vga_get(pdev, rsrc, 1);
>}
># 111 "/usr/src/linux-5.14.21-150500.53/include/linux/vgaarb.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int vga_get_uninterruptible(struct pci_dev *pdev,
>       unsigned int rsrc)
>{
>       return vga_get(pdev, rsrc, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vga_client_unregister(struct pci_dev *pdev)
>{
> vga_client_register(pdev, ((void *)0));
>}
># 173 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cacheflush.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/cacheflush.h" 1
>
>
>
>
>struct mm_struct;
>struct vm_area_struct;
>struct page;
>struct address_space;
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_all(void)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_mm(struct mm_struct *mm)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_dup_mm(struct mm_struct *mm)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_range(struct vm_area_struct *vma,
>         unsigned long start,
>         unsigned long end)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_page(struct vm_area_struct *vma,
>        unsigned long vmaddr,
>        unsigned long pfn)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_dcache_page(struct page *page)
>{
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_dcache_mmap_lock(struct address_space *mapping)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_dcache_mmap_unlock(struct address_space *mapping)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_icache_range(unsigned long start, unsigned long end)
>{
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_icache_page(struct vm_area_struct *vma,
>         struct page *page)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_icache_user_page(struct vm_area_struct *vma,
>        struct page *page,
>        unsigned long addr, int len)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_vmap(unsigned long start, unsigned long end)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_cache_vunmap(unsigned long start, unsigned long end)
>{
>}
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/cacheflush.h" 2
>
>
>void clflush_cache_range(void *addr, unsigned int size);
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem-internal.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem-internal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kmap_local_fork(struct task_struct *tsk) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kmap_assert_nomap(void) { }
># 148 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem-internal.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *kmap_to_page(void *addr)
>{
> return (((struct page *)vmemmap_base) + (__phys_addr_nodebug((unsigned long)(addr)) >> 12));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap(struct page *page)
>{
> do { might_resched(); } while (0);
> return lowmem_page_address(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kunmap_high(struct page *page) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kmap_flush_unused(void) { }
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kunmap(struct page *page)
>{
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_local_page(struct page *page)
>{
> return lowmem_page_address(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_local_page_prot(struct page *page, pgprot_t prot)
>{
> return kmap_local_page(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_local_pfn(unsigned long pfn)
>{
> return kmap_local_page((((struct page *)vmemmap_base) + (pfn)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __kunmap_local(void *addr)
>{
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_atomic(struct page *page)
>{
> if (0)
>  migrate_disable();
> else
>  do { __preempt_count_add(1); __asm__ __volatile__("": : :"memory"); } while (0);
> pagefault_disable();
> return lowmem_page_address(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_atomic_prot(struct page *page, pgprot_t prot)
>{
> return kmap_atomic(page);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_atomic_pfn(unsigned long pfn)
>{
> return kmap_atomic((((struct page *)vmemmap_base) + (pfn)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __kunmap_atomic(void *addr)
>{
>
>
>
> pagefault_enable();
> if (0)
>  migrate_enable();
> else
>  do { __asm__ __volatile__("": : :"memory"); if (__builtin_expect(!!(__preempt_count_dec_and_test()), 0)) do { ; asm volatile ("call " "__SCT__preempt_schedule" : "+r" (current_stack_pointer)); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int nr_free_highpages(void) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long totalhigh_pages(void) { return 0UL; }
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h" 2
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap(struct page *page);
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kunmap(struct page *page);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *kmap_to_page(void *addr);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kmap_flush_unused(void);
># 97 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_local_page(struct page *page);
># 110 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *kmap_atomic(struct page *page);
># 124 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int nr_free_highpages(void);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long totalhigh_pages(void);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_anon_page(struct vm_area_struct *vma, struct page *page, unsigned long vmaddr)
>{
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void flush_kernel_vmap_range(void *vaddr, int size)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void invalidate_kernel_vmap_range(void *vaddr, int size)
>{
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_user_highpage(struct page *page, unsigned long vaddr)
>{
> void *addr = kmap_atomic(page);
> clear_user_page(addr, vaddr, page);
> do { do { extern void __compiletime_assert_291(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((addr), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((addr)), typeof(struct page *))))) __compiletime_assert_291(); } while (0); __kunmap_atomic(addr); } while (0);
>}
># 178 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_highpage(struct page *page)
>{
> void *kaddr = kmap_atomic(page);
> clear_page(kaddr);
> do { do { extern void __compiletime_assert_292(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((kaddr), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((kaddr)), typeof(struct page *))))) __compiletime_assert_292(); } while (0); __kunmap_atomic(kaddr); } while (0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tag_clear_highpage(struct page *page)
>{
>}
># 201 "/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zero_user_segments(struct page *page,
>  unsigned start1, unsigned end1,
>  unsigned start2, unsigned end2)
>{
> void *kaddr = kmap_atomic(page);
> unsigned int i;
>
> do { if (__builtin_expect(!!(end1 > page_size(page) || end2 > page_size(page)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/highmem.h"), "i" (208), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("293" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "293" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
>
> if (end1 > start1)
>  memset(kaddr + start1, 0, end1 - start1);
>
> if (end2 > start2)
>  memset(kaddr + start2, 0, end2 - start2);
>
> do { do { extern void __compiletime_assert_294(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((kaddr), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((kaddr)), typeof(struct page *))))) __compiletime_assert_294(); } while (0); __kunmap_atomic(kaddr); } while (0);
> for (i = 0; i < compound_nr(page); i++)
>  flush_dcache_page(page + i);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zero_user_segment(struct page *page,
> unsigned start, unsigned end)
>{
> zero_user_segments(page, start, end, 0, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void zero_user(struct page *page,
> unsigned start, unsigned size)
>{
> zero_user_segments(page, start, start + size, 0, 0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void copy_user_highpage(struct page *to, struct page *from,
> unsigned long vaddr, struct vm_area_struct *vma)
>{
> char *vfrom, *vto;
>
> vfrom = kmap_atomic(from);
> vto = kmap_atomic(to);
> copy_user_page(vto, vfrom, vaddr, to);
> do { do { extern void __compiletime_assert_295(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((vto), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((vto)), typeof(struct page *))))) __compiletime_assert_295(); } while (0); __kunmap_atomic(vto); } while (0);
> do { do { extern void __compiletime_assert_296(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((vfrom), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((vfrom)), typeof(struct page *))))) __compiletime_assert_296(); } while (0); __kunmap_atomic(vfrom); } while (0);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void copy_highpage(struct page *to, struct page *from)
>{
> char *vfrom, *vto;
>
> vfrom = kmap_atomic(from);
> vto = kmap_atomic(to);
> copy_page(vto, vfrom);
> do { do { extern void __compiletime_assert_297(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((vto), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((vto)), typeof(struct page *))))) __compiletime_assert_297(); } while (0); __kunmap_atomic(vto); } while (0);
> do { do { extern void __compiletime_assert_298(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((vfrom), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((vfrom)), typeof(struct page *))))) __compiletime_assert_298(); } while (0); __kunmap_atomic(vfrom); } while (0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcpy_page(struct page *dst_page, size_t dst_off,
>          struct page *src_page, size_t src_off,
>          size_t len)
>{
> char *dst = kmap_local_page(dst_page);
> char *src = kmap_local_page(src_page);
>
> ((void)(sizeof(( long)(dst_off + len > ((1UL) << 12) || src_off + len > ((1UL) << 12)))));
> memcpy(dst + dst_off, src + src_off, len);
> do { do { extern void __compiletime_assert_299(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((src), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((src)), typeof(struct page *))))) __compiletime_assert_299(); } while (0); __kunmap_local(src); } while (0);
> do { do { extern void __compiletime_assert_300(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((dst), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((dst)), typeof(struct page *))))) __compiletime_assert_300(); } while (0); __kunmap_local(dst); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memmove_page(struct page *dst_page, size_t dst_off,
>          struct page *src_page, size_t src_off,
>          size_t len)
>{
> char *dst = kmap_local_page(dst_page);
> char *src = kmap_local_page(src_page);
>
> ((void)(sizeof(( long)(dst_off + len > ((1UL) << 12) || src_off + len > ((1UL) << 12)))));
> memmove(dst + dst_off, src + src_off, len);
> do { do { extern void __compiletime_assert_301(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((src), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((src)), typeof(struct page *))))) __compiletime_assert_301(); } while (0); __kunmap_local(src); } while (0);
> do { do { extern void __compiletime_assert_302(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((dst), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((dst)), typeof(struct page *))))) __compiletime_assert_302(); } while (0); __kunmap_local(dst); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memset_page(struct page *page, size_t offset, int val,
>          size_t len)
>{
> char *addr = kmap_local_page(page);
>
> ((void)(sizeof(( long)(offset + len > ((1UL) << 12)))));
> memset(addr + offset, val, len);
> do { do { extern void __compiletime_assert_303(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((addr), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((addr)), typeof(struct page *))))) __compiletime_assert_303(); } while (0); __kunmap_local(addr); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcpy_from_page(char *to, struct page *page,
>        size_t offset, size_t len)
>{
> char *from = kmap_local_page(page);
>
> ((void)(sizeof(( long)(offset + len > ((1UL) << 12)))));
> memcpy(to, from + offset, len);
> do { do { extern void __compiletime_assert_304(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((from), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((from)), typeof(struct page *))))) __compiletime_assert_304(); } while (0); __kunmap_local(from); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcpy_to_page(struct page *page, size_t offset,
>      const char *from, size_t len)
>{
> char *to = kmap_local_page(page);
>
> ((void)(sizeof(( long)(offset + len > ((1UL) << 12)))));
> memcpy(to + offset, from, len);
> flush_dcache_page(page);
> do { do { extern void __compiletime_assert_305(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((to), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((to)), typeof(struct page *))))) __compiletime_assert_305(); } while (0); __kunmap_local(to); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memzero_page(struct page *page, size_t offset, size_t len)
>{
> char *addr = kmap_local_page(page);
> memset(addr + offset, 0, len);
> flush_dcache_page(page);
> do { do { extern void __compiletime_assert_306(void) __attribute__((__error__("BUILD_BUG_ON failed: " "__same_type((addr), struct page *)"))); if (!(!(__builtin_types_compatible_p(typeof((addr)), typeof(struct page *))))) __compiletime_assert_306(); } while (0); __kunmap_local(addr); } while (0);
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/hugetlb_inline.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/hugetlb_inline.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_vm_hugetlb_page(struct vm_area_struct *vma)
>{
> return !!(vma->vm_flags & 0x00400000);
>}
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h" 2
>
>struct pagevec;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mapping_empty(struct address_space *mapping)
>{
> return xa_empty(&mapping->i_pages);
>}
>
>
>
>
>enum mapping_flags {
> AS_EIO = 0,
> AS_ENOSPC = 1,
> AS_MM_ALL_LOCKS = 2,
> AS_UNEVICTABLE = 3,
> AS_EXITING = 4,
>
> AS_NO_WRITEBACK_TAGS = 5,
> AS_THP_SUPPORT = 6,
>};
># 54 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_set_error(struct address_space *mapping, int error)
>{
> if (__builtin_expect(!!(!error), 1))
>  return;
>
>
> __filemap_set_wb_err(mapping, error);
>
>
> if (mapping->host)
>  errseq_set(&mapping->host->i_sb->s_wb_err, error);
>
>
> if (error == -28)
>  set_bit(AS_ENOSPC, &mapping->flags);
> else
>  set_bit(AS_EIO, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_set_unevictable(struct address_space *mapping)
>{
> set_bit(AS_UNEVICTABLE, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_clear_unevictable(struct address_space *mapping)
>{
> clear_bit(AS_UNEVICTABLE, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mapping_unevictable(struct address_space *mapping)
>{
> return mapping && test_bit(AS_UNEVICTABLE, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_set_exiting(struct address_space *mapping)
>{
> set_bit(AS_EXITING, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mapping_exiting(struct address_space *mapping)
>{
> return test_bit(AS_EXITING, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_set_no_writeback_tags(struct address_space *mapping)
>{
> set_bit(AS_NO_WRITEBACK_TAGS, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mapping_use_writeback_tags(struct address_space *mapping)
>{
> return !test_bit(AS_NO_WRITEBACK_TAGS, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) gfp_t mapping_gfp_mask(struct address_space * mapping)
>{
> return mapping->gfp_mask;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) gfp_t mapping_gfp_constraint(struct address_space *mapping,
>  gfp_t gfp_mask)
>{
> return mapping_gfp_mask(mapping) & gfp_mask;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mapping_set_gfp_mask(struct address_space *m, gfp_t mask)
>{
> m->gfp_mask = mask;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mapping_thp_support(struct address_space *mapping)
>{
> return test_bit(AS_THP_SUPPORT, &mapping->flags);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int filemap_nr_thps(struct address_space *mapping)
>{
>
> return atomic_read(&mapping->nr_thps);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_nr_thps_inc(struct address_space *mapping)
>{
>
> if (!mapping_thp_support(mapping))
>  atomic_inc(&mapping->nr_thps);
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void filemap_nr_thps_dec(struct address_space *mapping)
>{
>
> if (!mapping_thp_support(mapping))
>  atomic_dec(&mapping->nr_thps);
>
>
>
>}
>
>void release_pages(struct page **pages, int nr);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct address_space *page_mapping_file(struct page *page)
>{
> if (__builtin_expect(!!(PageSwapCache(page)), 0))
>  return ((void *)0);
> return page_mapping(page);
>}
># 219 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __page_cache_add_speculative(struct page *page, int count)
>{
># 238 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
> if (__builtin_expect(!!(!page_ref_add_unless(page, count, 0)), 0)) {
>
>
>
>
>
>  return 0;
> }
>
> ((void)(sizeof(( long)(PageTail(page)))));
>
> return 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_cache_get_speculative(struct page *page)
>{
> return __page_cache_add_speculative(page, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_cache_add_speculative(struct page *page, int count)
>{
> return __page_cache_add_speculative(page, count);
>}
># 270 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void attach_page_private(struct page *page, void *data)
>{
> get_page(page);
> set_page_private(page, (unsigned long)data);
> SetPagePrivate(page);
>}
># 286 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *detach_page_private(struct page *page)
>{
> void *data = (void *)((page)->private);
>
> if (!PagePrivate(page))
>  return ((void *)0);
> ClearPagePrivate(page);
> set_page_private(page, 0);
> put_page(page);
>
> return data;
>}
>
>
>extern struct page *__page_cache_alloc(gfp_t gfp);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *page_cache_alloc(struct address_space *x)
>{
> return __page_cache_alloc(mapping_gfp_mask(x));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) gfp_t readahead_gfp_mask(struct address_space *x)
>{
> return mapping_gfp_mask(x) | (( gfp_t)0x10000u) | (( gfp_t)0x2000u);
>}
>
>typedef int filler_t(void *, struct page *);
>
>unsigned long page_cache_next_miss(struct address_space *mapping,
>        unsigned long index, unsigned long max_scan);
>unsigned long page_cache_prev_miss(struct address_space *mapping,
>        unsigned long index, unsigned long max_scan);
># 335 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>struct page *pagecache_get_page(struct address_space *mapping, unsigned long offset,
>  int fgp_flags, gfp_t cache_gfp_mask);
># 348 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *find_get_page(struct address_space *mapping,
>     unsigned long offset)
>{
> return pagecache_get_page(mapping, offset, 0, 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *find_get_page_flags(struct address_space *mapping,
>     unsigned long offset, int fgp_flags)
>{
> return pagecache_get_page(mapping, offset, fgp_flags, 0);
>}
># 373 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *find_lock_page(struct address_space *mapping,
>     unsigned long index)
>{
> return pagecache_get_page(mapping, index, 0x00000002, 0);
>}
># 392 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *find_lock_head(struct address_space *mapping,
>     unsigned long index)
>{
> return pagecache_get_page(mapping, index, 0x00000002 | 0x00000080, 0);
>}
># 417 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *find_or_create_page(struct address_space *mapping,
>     unsigned long index, gfp_t gfp_mask)
>{
> return pagecache_get_page(mapping, index,
>     0x00000002|0x00000001|0x00000004,
>     gfp_mask);
>}
># 438 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *grab_cache_page_nowait(struct address_space *mapping,
>    unsigned long index)
>{
> return pagecache_get_page(mapping, index,
>   0x00000002|0x00000004|0x00000010|0x00000020,
>   mapping_gfp_mask(mapping));
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool thp_contains(struct page *head, unsigned long index)
>{
>
> if (PageHuge(head))
>  return head->index == index;
> return page_index(head) == (index & ~(thp_nr_pages(head) - 1UL));
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *find_subpage(struct page *head, unsigned long index)
>{
>
> if (PageHuge(head))
>  return head;
>
> return head + (index & (thp_nr_pages(head) - 1));
>}
>
>unsigned find_get_entries(struct address_space *mapping, unsigned long start,
>  unsigned long end, struct pagevec *pvec, unsigned long *indices);
>unsigned find_get_pages_range(struct address_space *mapping, unsigned long *start,
>   unsigned long end, unsigned int nr_pages,
>   struct page **pages);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned find_get_pages(struct address_space *mapping,
>   unsigned long *start, unsigned int nr_pages,
>   struct page **pages)
>{
> return find_get_pages_range(mapping, start, (unsigned long)-1, nr_pages,
>        pages);
>}
>unsigned find_get_pages_contig(struct address_space *mapping, unsigned long start,
>          unsigned int nr_pages, struct page **pages);
>unsigned find_get_pages_range_tag(struct address_space *mapping, unsigned long *index,
>   unsigned long end, xa_mark_t tag, unsigned int nr_pages,
>   struct page **pages);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned find_get_pages_tag(struct address_space *mapping,
>   unsigned long *index, xa_mark_t tag, unsigned int nr_pages,
>   struct page **pages)
>{
> return find_get_pages_range_tag(mapping, index, (unsigned long)-1, tag,
>     nr_pages, pages);
>}
>
>struct page *grab_cache_page_write_begin(struct address_space *mapping,
>   unsigned long index, unsigned flags);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *grab_cache_page(struct address_space *mapping,
>        unsigned long index)
>{
> return find_or_create_page(mapping, index, mapping_gfp_mask(mapping));
>}
>
>extern struct page * read_cache_page(struct address_space *mapping,
>    unsigned long index, filler_t *filler, void *data);
>extern struct page * read_cache_page_gfp(struct address_space *mapping,
>    unsigned long index, gfp_t gfp_mask);
>extern int read_cache_pages(struct address_space *mapping,
>  struct list_head *pages, filler_t *filler, void *data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *read_mapping_page(struct address_space *mapping,
>    unsigned long index, void *data)
>{
> return read_cache_page(mapping, index, ((void *)0), data);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_to_index(struct page *page)
>{
> struct page *head;
>
> if (__builtin_expect(!!(!PageTransTail(page)), 1))
>  return page->index;
>
> head = ((typeof(page))_compound_head(page));
>
>
>
>
> return head->index + page - head;
>}
>
>extern unsigned long hugetlb_basepage_index(struct page *page);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_to_pgoff(struct page *page)
>{
> if (__builtin_expect(!!(PageHuge(page)), 0))
>  return hugetlb_basepage_index(page);
> return page_to_index(page);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) loff_t page_offset(struct page *page)
>{
> return ((loff_t)page->index) << 12;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) loff_t page_file_offset(struct page *page)
>{
> return ((loff_t)page_index(page)) << 12;
>}
>
>extern unsigned long linear_hugepage_index(struct vm_area_struct *vma,
>         unsigned long address);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long linear_page_index(struct vm_area_struct *vma,
>     unsigned long address)
>{
> unsigned long pgoff;
> if (__builtin_expect(!!(is_vm_hugetlb_page(vma)), 0))
>  return linear_hugepage_index(vma, address);
> pgoff = (address - vma->vm_start) >> 12;
> pgoff += vma->vm_pgoff;
> return pgoff;
>}
>
>struct wait_page_key {
> struct page *page;
> int bit_nr;
> int page_match;
>};
>
>struct wait_page_queue {
> struct page *page;
> int bit_nr;
> wait_queue_entry_t wait;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool wake_page_match(struct wait_page_queue *wait_page,
>      struct wait_page_key *key)
>{
> if (wait_page->page != key->page)
>        return false;
> key->page_match = 1;
>
> if (wait_page->bit_nr != key->bit_nr)
>  return false;
>
> return true;
>}
>
>extern void __lock_page(struct page *page);
>extern int __lock_page_killable(struct page *page);
>extern int __lock_page_async(struct page *page, struct wait_page_queue *wait);
>extern int __lock_page_or_retry(struct page *page, struct mm_struct *mm,
>    unsigned int flags);
>extern void unlock_page(struct page *page);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int trylock_page(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
> return (__builtin_expect(!!(!test_and_set_bit_lock(PG_locked, &page->flags)), 1));
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lock_page(struct page *page)
>{
> do { might_resched(); } while (0);
> if (!trylock_page(page))
>  __lock_page(page);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int lock_page_killable(struct page *page)
>{
> do { might_resched(); } while (0);
> if (!trylock_page(page))
>  return __lock_page_killable(page);
> return 0;
>}
># 649 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int lock_page_async(struct page *page,
>      struct wait_page_queue *wait)
>{
> if (!trylock_page(page))
>  return __lock_page_async(page, wait);
> return 0;
>}
># 664 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int lock_page_or_retry(struct page *page, struct mm_struct *mm,
>         unsigned int flags)
>{
> do { might_resched(); } while (0);
> return trylock_page(page) || __lock_page_or_retry(page, mm, flags);
>}
>
>
>
>
>
>extern void wait_on_page_bit(struct page *page, int bit_nr);
>extern int wait_on_page_bit_killable(struct page *page, int bit_nr);
># 685 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wait_on_page_locked(struct page *page)
>{
> if (PageLocked(page))
>  wait_on_page_bit(((typeof(page))_compound_head(page)), PG_locked);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int wait_on_page_locked_killable(struct page *page)
>{
> if (!PageLocked(page))
>  return 0;
> return wait_on_page_bit_killable(((typeof(page))_compound_head(page)), PG_locked);
>}
>
>int put_and_wait_on_page_locked(struct page *page, int state);
>void wait_on_page_writeback(struct page *page);
>int wait_on_page_writeback_killable(struct page *page);
>extern void end_page_writeback(struct page *page);
>void wait_for_stable_page(struct page *page);
>
>void __set_page_dirty(struct page *, struct address_space *, int warn);
>int __set_page_dirty_nobuffers(struct page *page);
>int __set_page_dirty_no_writeback(struct page *page);
>
>void page_endio(struct page *page, bool is_write, int err);
># 719 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_page_private_2(struct page *page)
>{
> page = ((typeof(page))_compound_head(page));
> get_page(page);
> SetPagePrivate2(page);
>}
>
>void end_page_private_2(struct page *page);
>void wait_on_page_private_2(struct page *page);
>int wait_on_page_private_2_killable(struct page *page);
>
>
>
>
>extern void add_page_wait_queue(struct page *page, wait_queue_entry_t *waiter);
>
>
>
>
>size_t fault_in_writeable(char *uaddr, size_t size);
>size_t fault_in_subpage_writeable(char *uaddr, size_t size);
>size_t fault_in_readable(const char *uaddr, size_t size);
>
>int add_to_page_cache_locked(struct page *page, struct address_space *mapping,
>    unsigned long index, gfp_t gfp_mask);
>int add_to_page_cache_lru(struct page *page, struct address_space *mapping,
>    unsigned long index, gfp_t gfp_mask);
>extern void delete_from_page_cache(struct page *page);
>extern void __delete_from_page_cache(struct page *page, void *shadow);
>void replace_page_cache_page(struct page *old, struct page *new);
>void delete_from_page_cache_batch(struct address_space *mapping,
>      struct pagevec *pvec);
>loff_t mapping_seek_hole_data(struct address_space *, loff_t start, loff_t end,
>  int whence);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int add_to_page_cache(struct page *page,
>  struct address_space *mapping, unsigned long offset, gfp_t gfp_mask)
>{
> int error;
>
> __SetPageLocked(page);
> error = add_to_page_cache_locked(page, mapping, offset, gfp_mask);
> if (__builtin_expect(!!(error), 0))
>  __ClearPageLocked(page);
> return error;
>}
>
>bool filemap_range_has_writeback(struct address_space *mapping,
>     loff_t start_byte, loff_t end_byte);
># 787 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool filemap_range_needs_writeback(struct address_space *mapping,
>       loff_t start_byte,
>       loff_t end_byte)
>{
> if (!mapping->nrpages)
>  return false;
> if (!mapping_tagged(mapping, (( xa_mark_t)0U)) &&
>     !mapping_tagged(mapping, (( xa_mark_t)1U)))
>  return false;
> return filemap_range_has_writeback(mapping, start_byte, end_byte);
>}
># 815 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>struct readahead_control {
> struct file *file;
> struct address_space *mapping;
> struct file_ra_state *ra;
>
> unsigned long _index;
> unsigned int _nr_pages;
> unsigned int _batch_count;
>};
># 835 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>void page_cache_ra_unbounded(struct readahead_control *,
>  unsigned long nr_to_read, unsigned long lookahead_count);
>void page_cache_sync_ra(struct readahead_control *, unsigned long req_count);
>void page_cache_async_ra(struct readahead_control *, struct page *,
>  unsigned long req_count);
>void readahead_expand(struct readahead_control *ractl,
>        loff_t new_start, size_t new_len);
># 856 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void page_cache_sync_readahead(struct address_space *mapping,
>  struct file_ra_state *ra, struct file *file, unsigned long index,
>  unsigned long req_count)
>{
> struct readahead_control ractl = { .file = file, .mapping = mapping, .ra = ra, ._index = index, };
> page_cache_sync_ra(&ractl, req_count);
>}
># 879 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void page_cache_async_readahead(struct address_space *mapping,
>  struct file_ra_state *ra, struct file *file,
>  struct page *page, unsigned long index, unsigned long req_count)
>{
> struct readahead_control ractl = { .file = file, .mapping = mapping, .ra = ra, ._index = index, };
> page_cache_async_ra(&ractl, page, req_count);
>}
># 897 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *readahead_page(struct readahead_control *rac)
>{
> struct page *page;
>
> do { if (__builtin_expect(!!(rac->_batch_count > rac->_nr_pages), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"), "i" (901), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("307" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "307" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> rac->_nr_pages -= rac->_batch_count;
> rac->_index += rac->_batch_count;
>
> if (!rac->_nr_pages) {
>  rac->_batch_count = 0;
>  return ((void *)0);
> }
>
> page = xa_load(&rac->mapping->i_pages, rac->_index);
> ((void)(sizeof(( long)(!PageLocked(page)))));
> rac->_batch_count = thp_nr_pages(page);
>
> return page;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __readahead_batch(struct readahead_control *rac,
>  struct page **array, unsigned int array_sz)
>{
> unsigned int i = 0;
> struct xa_state xas = { .xa = &rac->mapping->i_pages, .xa_index = 0, .xa_shift = 0, .xa_sibs = 0, .xa_offset = 0, .xa_pad = 0, .xa_node = ((struct xa_node *)3UL), .xa_alloc = ((void *)0), .xa_update = ((void *)0) };
> struct page *page;
>
> do { if (__builtin_expect(!!(rac->_batch_count > rac->_nr_pages), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"), "i" (924), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("308" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "308" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> rac->_nr_pages -= rac->_batch_count;
> rac->_index += rac->_batch_count;
> rac->_batch_count = 0;
>
> xas_set(&xas, rac->_index);
> rcu_read_lock();
> for (page = xas_find(&xas, rac->_index + rac->_nr_pages - 1); page; page = xas_next_entry(&xas, rac->_index + rac->_nr_pages - 1)) {
>  if (xas_retry(&xas, page))
>   continue;
>  ((void)(sizeof(( long)(!PageLocked(page)))));
>  ((void)(sizeof(( long)(PageTail(page)))));
>  array[i++] = page;
>  rac->_batch_count += thp_nr_pages(page);
>
>
>
>
>
>
>
>  if (PageHead(page))
>   xas_set(&xas, rac->_index + rac->_batch_count);
>
>  if (i == array_sz)
>   break;
> }
> rcu_read_unlock();
>
> return i;
>}
># 974 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) loff_t readahead_pos(struct readahead_control *rac)
>{
> return (loff_t)rac->_index * ((1UL) << 12);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t readahead_length(struct readahead_control *rac)
>{
> return rac->_nr_pages * ((1UL) << 12);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long readahead_index(struct readahead_control *rac)
>{
> return rac->_index;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int readahead_count(struct readahead_control *rac)
>{
> return rac->_nr_pages;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t readahead_batch_length(struct readahead_control *rac)
>{
> return rac->_batch_count * ((1UL) << 12);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long dir_pages(struct inode *inode)
>{
> return (unsigned long)(inode->i_size + ((1UL) << 12) - 1) >>
>          12;
>}
># 1029 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int page_mkwrite_check_truncate(struct page *page,
>           struct inode *inode)
>{
> loff_t size = i_size_read(inode);
> unsigned long index = size >> 12;
> int offset = ((unsigned long)(size) & ~(~(((1UL) << 12)-1)));
>
> if (page->mapping != inode->i_mapping)
>  return -14;
>
>
> if (page->index < index)
>  return ((1UL) << 12);
>
> if (page->index > index || !offset)
>  return -14;
>
> return offset;
>}
># 1060 "/usr/src/linux-5.14.21-150500.53/include/linux/pagemap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned int i_blocks_per_page(struct inode *inode, struct page *page)
>{
> return thp_size(page) >> inode->i_blkbits;
>}
># 177 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>struct cma;
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>struct dma_map_ops {
> unsigned int flags;
>
> void *(*alloc)(struct device *dev, size_t size,
>   dma_addr_t *dma_handle, gfp_t gfp,
>   unsigned long attrs);
> void (*free)(struct device *dev, size_t size, void *vaddr,
>   dma_addr_t dma_handle, unsigned long attrs);
> struct page *(*alloc_pages)(struct device *dev, size_t size,
>   dma_addr_t *dma_handle, enum dma_data_direction dir,
>   gfp_t gfp);
> void (*free_pages)(struct device *dev, size_t size, struct page *vaddr,
>   dma_addr_t dma_handle, enum dma_data_direction dir);
> struct sg_table *(*alloc_noncontiguous)(struct device *dev, size_t size,
>   enum dma_data_direction dir, gfp_t gfp,
>   unsigned long attrs);
> void (*free_noncontiguous)(struct device *dev, size_t size,
>   struct sg_table *sgt, enum dma_data_direction dir);
> int (*mmap)(struct device *, struct vm_area_struct *,
>   void *, dma_addr_t, size_t, unsigned long attrs);
>
> int (*get_sgtable)(struct device *dev, struct sg_table *sgt,
>   void *cpu_addr, dma_addr_t dma_addr, size_t size,
>   unsigned long attrs);
>
> dma_addr_t (*map_page)(struct device *dev, struct page *page,
>   unsigned long offset, size_t size,
>   enum dma_data_direction dir, unsigned long attrs);
> void (*unmap_page)(struct device *dev, dma_addr_t dma_handle,
>   size_t size, enum dma_data_direction dir,
>   unsigned long attrs);
>
>
>
>
>
> int (*map_sg)(struct device *dev, struct scatterlist *sg, int nents,
>   enum dma_data_direction dir, unsigned long attrs);
> void (*unmap_sg)(struct device *dev, struct scatterlist *sg, int nents,
>   enum dma_data_direction dir, unsigned long attrs);
> dma_addr_t (*map_resource)(struct device *dev, phys_addr_t phys_addr,
>   size_t size, enum dma_data_direction dir,
>   unsigned long attrs);
> void (*unmap_resource)(struct device *dev, dma_addr_t dma_handle,
>   size_t size, enum dma_data_direction dir,
>   unsigned long attrs);
> void (*sync_single_for_cpu)(struct device *dev, dma_addr_t dma_handle,
>   size_t size, enum dma_data_direction dir);
> void (*sync_single_for_device)(struct device *dev,
>   dma_addr_t dma_handle, size_t size,
>   enum dma_data_direction dir);
> void (*sync_sg_for_cpu)(struct device *dev, struct scatterlist *sg,
>   int nents, enum dma_data_direction dir);
> void (*sync_sg_for_device)(struct device *dev, struct scatterlist *sg,
>   int nents, enum dma_data_direction dir);
> void (*cache_sync)(struct device *dev, void *vaddr, size_t size,
>   enum dma_data_direction direction);
> int (*dma_supported)(struct device *dev, u64 mask);
> u64 (*get_required_mask)(struct device *dev);
> size_t (*max_mapping_size)(struct device *dev);
> size_t (*opt_mapping_size)(void);
> unsigned long (*get_merge_boundary)(struct device *dev);
>};
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/dma-mapping.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/dma-mapping.h"
>extern int iommu_merge;
>extern int panic_on_overflow;
>
>extern const struct dma_map_ops *dma_ops;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct dma_map_ops *get_arch_dma_ops(struct bus_type *bus)
>{
> return dma_ops;
>}
># 88 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h" 2
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct dma_map_ops *get_dma_ops(struct device *dev)
>{
> if (dev->dma_ops)
>  return dev->dma_ops;
> return get_arch_dma_ops(dev->bus);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_dma_ops(struct device *dev,
>          const struct dma_map_ops *dma_ops)
>{
> dev->dma_ops = dma_ops;
>}
># 113 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>extern struct cma *dma_contiguous_default_area;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cma *dev_get_cma_area(struct device *dev)
>{
> if (dev && dev->cma_area)
>  return dev->cma_area;
> return dma_contiguous_default_area;
>}
>
>void dma_contiguous_reserve(phys_addr_t addr_limit);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) dma_contiguous_reserve_area(phys_addr_t size, phys_addr_t base,
>  phys_addr_t limit, struct cma **res_cma, bool fixed);
>
>struct page *dma_alloc_from_contiguous(struct device *dev, size_t count,
>           unsigned int order, bool no_warn);
>bool dma_release_from_contiguous(struct device *dev, struct page *pages,
>     int count);
>struct page *dma_alloc_contiguous(struct device *dev, size_t size, gfp_t gfp);
>void dma_free_contiguous(struct device *dev, struct page *page, size_t size);
>
>void dma_contiguous_early_fixup(phys_addr_t base, unsigned long size);
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_pernuma_cma_reserve(void) { }
># 193 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_declare_coherent_memory(struct device *dev,
>  phys_addr_t phys_addr, dma_addr_t device_addr, size_t size)
>{
> return -38;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dma_alloc_from_global_coherent(struct device *dev,
>  ssize_t size, dma_addr_t *dma_handle)
>{
> return ((void *)0);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_release_from_global_coherent(int order, void *vaddr)
>{
> return 0;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int dma_mmap_from_global_coherent(struct vm_area_struct *vma,
>  void *cpu_addr, size_t size, int *ret)
>{
> return 0;
>}
># 225 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>struct dma_sgt_handle {
> struct sg_table sgt;
> struct page **pages;
>};
>
>
>
>int dma_common_get_sgtable(struct device *dev, struct sg_table *sgt,
>  void *cpu_addr, dma_addr_t dma_addr, size_t size,
>  unsigned long attrs);
>int dma_common_mmap(struct device *dev, struct vm_area_struct *vma,
>  void *cpu_addr, dma_addr_t dma_addr, size_t size,
>  unsigned long attrs);
>struct page *dma_common_alloc_pages(struct device *dev, size_t size,
>  dma_addr_t *dma_handle, enum dma_data_direction dir, gfp_t gfp);
>void dma_common_free_pages(struct device *dev, size_t size, struct page *vaddr,
>  dma_addr_t dma_handle, enum dma_data_direction dir);
>
>struct page **dma_common_find_pages(void *cpu_addr);
>void *dma_common_contiguous_remap(struct page *page, size_t size, pgprot_t prot,
>  const void *caller);
>void *dma_common_pages_remap(struct page **pages, size_t size, pgprot_t prot,
>  const void *caller);
>void dma_common_free_remap(void *cpu_addr, size_t size);
>
>struct page *dma_alloc_from_pool(struct device *dev, size_t size,
>  void **cpu_addr, gfp_t flags,
>  bool (*phys_addr_ok)(struct device *, phys_addr_t, size_t));
>bool dma_free_from_pool(struct device *dev, void *start, size_t size);
>
>int dma_direct_set_offset(struct device *dev, phys_addr_t cpu_start,
>  dma_addr_t dma_start, u64 size);
># 267 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool dev_is_dma_coherent(struct device *dev)
>{
> return true;
>}
>
>
>void *arch_dma_alloc(struct device *dev, size_t size, dma_addr_t *dma_handle,
>  gfp_t gfp, unsigned long attrs);
>void arch_dma_free(struct device *dev, size_t size, void *cpu_addr,
>  dma_addr_t dma_addr, unsigned long attrs);
># 289 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>pgprot_t dma_pgprot(struct device *dev, pgprot_t prot, unsigned long attrs);
># 302 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_sync_dma_for_device(phys_addr_t paddr, size_t size,
>  enum dma_data_direction dir)
>{
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_sync_dma_for_cpu(phys_addr_t paddr, size_t size,
>  enum dma_data_direction dir)
>{
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_sync_dma_for_cpu_all(void)
>{
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_dma_prep_coherent(struct page *page, size_t size)
>{
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_dma_mark_clean(phys_addr_t paddr, size_t size)
>{
>}
>
>
>void *arch_dma_set_uncached(void *addr, size_t size);
>void arch_dma_clear_uncached(void *addr, size_t size);
># 363 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_setup_dma_ops(struct device *dev, u64 dma_base,
>  u64 size, const struct iommu_ops *iommu, bool coherent)
>{
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_teardown_dma_ops(struct device *dev)
>{
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dma_debug_add_bus(struct bus_type *bus)
>{
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void debug_dma_dump_mappings(struct device *dev)
>{
>}
>
>
>extern const struct dma_map_ops dma_dummy_ops;
>
>enum pci_p2pdma_map_type {
>
>
>
>
>
> PCI_P2PDMA_MAP_UNKNOWN = 0,
>
>
>
>
>
>
>
> PCI_P2PDMA_MAP_NOT_SUPPORTED,
>
>
>
>
>
>
>
> PCI_P2PDMA_MAP_BUS_ADDR,
># 422 "/usr/src/linux-5.14.21-150500.53/include/linux/dma-map-ops.h"
> PCI_P2PDMA_MAP_THRU_HOST_BRIDGE,
>};
>
>struct pci_p2pdma_map_state {
> struct dev_pagemap *pgmap;
> int map;
> u64 bus_off;
>};
>
>
>enum pci_p2pdma_map_type
>pci_p2pdma_map_segment(struct pci_p2pdma_map_state *state, struct device *dev,
>         struct scatterlist *sg);
># 181 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 196 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kthread-q.h" 1
># 88 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kthread-q.h"
>typedef struct nv_kthread_q nv_kthread_q_t;
>typedef struct nv_kthread_q_item nv_kthread_q_item_t;
>
>typedef void (*nv_q_func_t)(void *args);
>
>struct nv_kthread_q
>{
>    struct list_head q_list_head;
>    spinlock_t q_lock;
>
>
>
>    struct semaphore q_sem;
>    atomic_t main_loop_should_exit;
>
>    struct task_struct *q_kthread;
>};
>
>struct nv_kthread_q_item
>{
>    struct list_head q_list_node;
>    nv_q_func_t function_to_run;
>    void *function_args;
>};
># 137 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kthread-q.h"
>int nv_kthread_q_init(nv_kthread_q_t *q, const char *qname);
># 152 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kthread-q.h"
>void nv_kthread_q_stop(nv_kthread_q_t *q);
># 174 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kthread-q.h"
>void nv_kthread_q_flush(nv_kthread_q_t *q);
>
>
>
>
>void nv_kthread_q_item_init(nv_kthread_q_item_t *q_item,
>                            nv_q_func_t function_to_run,
>                            void *function_args);
># 209 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-kthread-q.h"
>int nv_kthread_q_schedule_q_item(nv_kthread_q_t *q,
>                                 nv_kthread_q_item_t *q_item);
>
>
>int nv_kthread_q_run_self_test(void);
># 197 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/proc_fs.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/proc_fs.h"
>struct proc_dir_entry;
>struct seq_file;
>struct seq_operations;
>
>enum {
>
>
>
>
>
>
> PROC_ENTRY_PERMANENT = 0U,
>
>
>
>};
>
>struct proc_ops {
> unsigned int proc_flags;
> int (*proc_open)(struct inode *, struct file *);
> ssize_t (*proc_read)(struct file *, char *, size_t, loff_t *);
> ssize_t (*proc_read_iter)(struct kiocb *, struct iov_iter *);
> ssize_t (*proc_write)(struct file *, const char *, size_t, loff_t *);
>
> loff_t (*proc_lseek)(struct file *, loff_t, int);
> int (*proc_release)(struct inode *, struct file *);
> __poll_t (*proc_poll)(struct file *, struct poll_table_struct *);
> long (*proc_ioctl)(struct file *, unsigned int, unsigned long);
>
> long (*proc_compat_ioctl)(struct file *, unsigned int, unsigned long);
>
> int (*proc_mmap)(struct file *, struct vm_area_struct *);
> unsigned long (*proc_get_unmapped_area)(struct file *, unsigned long, unsigned long, unsigned long, unsigned long);
>} __attribute__((__designated_init__));
>
>
>enum proc_hidepid {
> HIDEPID_OFF = 0,
> HIDEPID_NO_ACCESS = 1,
> HIDEPID_INVISIBLE = 2,
> HIDEPID_NOT_PTRACEABLE = 4,
>};
>
>
>enum proc_pidonly {
> PROC_PIDONLY_OFF = 0,
> PROC_PIDONLY_ON = 1,
>};
>
>struct proc_fs_info {
> struct pid_namespace *pid_ns;
> struct dentry *proc_self;
> struct dentry *proc_thread_self;
> kgid_t pid_gid;
> enum proc_hidepid hide_pid;
> enum proc_pidonly pidonly;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct proc_fs_info *proc_sb_info(struct super_block *sb)
>{
> return sb->s_fs_info;
>}
>
>
>
>typedef int (*proc_write_t)(struct file *, char *, size_t);
>
>extern void proc_root_init(void);
>extern void proc_flush_pid(struct pid *);
>
>extern struct proc_dir_entry *proc_symlink(const char *,
>  struct proc_dir_entry *, const char *);
>struct proc_dir_entry *_proc_mkdir(const char *, umode_t, struct proc_dir_entry *, void *, bool);
>extern struct proc_dir_entry *proc_mkdir(const char *, struct proc_dir_entry *);
>extern struct proc_dir_entry *proc_mkdir_data(const char *, umode_t,
>           struct proc_dir_entry *, void *);
>extern struct proc_dir_entry *proc_mkdir_mode(const char *, umode_t,
>           struct proc_dir_entry *);
>struct proc_dir_entry *proc_create_mount_point(const char *name);
>
>struct proc_dir_entry *proc_create_seq_private(const char *name, umode_t mode,
>  struct proc_dir_entry *parent, const struct seq_operations *ops,
>  unsigned int state_size, void *data);
>
>
>
>
>struct proc_dir_entry *proc_create_single_data(const char *name, umode_t mode,
>  struct proc_dir_entry *parent,
>  int (*show)(struct seq_file *, void *), void *data);
>
>
>
>extern struct proc_dir_entry *proc_create_data(const char *, umode_t,
>            struct proc_dir_entry *,
>            const struct proc_ops *,
>            void *);
>
>struct proc_dir_entry *proc_create(const char *name, umode_t mode, struct proc_dir_entry *parent, const struct proc_ops *proc_ops);
>extern void proc_set_size(struct proc_dir_entry *, loff_t);
>extern void proc_set_user(struct proc_dir_entry *, kuid_t, kgid_t);
>extern void *PDE_DATA(const struct inode *);
>extern void *proc_get_parent_data(const struct inode *);
>extern void proc_remove(struct proc_dir_entry *);
>extern void remove_proc_entry(const char *, struct proc_dir_entry *);
>extern int remove_proc_subtree(const char *, struct proc_dir_entry *);
>
>struct proc_dir_entry *proc_create_net_data(const char *name, umode_t mode,
>  struct proc_dir_entry *parent, const struct seq_operations *ops,
>  unsigned int state_size, void *data);
>
>
>struct proc_dir_entry *proc_create_net_single(const char *name, umode_t mode,
>  struct proc_dir_entry *parent,
>  int (*show)(struct seq_file *, void *), void *data);
>struct proc_dir_entry *proc_create_net_data_write(const char *name, umode_t mode,
>        struct proc_dir_entry *parent,
>        const struct seq_operations *ops,
>        proc_write_t write,
>        unsigned int state_size, void *data);
>struct proc_dir_entry *proc_create_net_single_write(const char *name, umode_t mode,
>          struct proc_dir_entry *parent,
>          int (*show)(struct seq_file *, void *),
>          proc_write_t write,
>          void *data);
>extern struct pid *tgid_pidfd_to_pid(const struct file *file);
>
>struct bpf_iter_aux_info;
>extern int bpf_iter_init_seq_net(void *priv_data, struct bpf_iter_aux_info *aux);
>extern void bpf_iter_fini_seq_net(void *priv_data);
>
>
>
>
>
>
>int proc_pid_arch_status(struct seq_file *m, struct pid_namespace *ns,
>   struct pid *pid, struct task_struct *task);
># 204 "/usr/src/linux-5.14.21-150500.53/include/linux/proc_fs.h"
>struct net;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct proc_dir_entry *proc_net_mkdir(
> struct net *net, const char *name, struct proc_dir_entry *parent)
>{
> return _proc_mkdir(name, 0, parent, net, true);
>}
>
>struct ns_common;
>int open_related_ns(struct ns_common *ns,
>     struct ns_common *(*get_ns)(struct ns_common *ns));
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid_namespace *proc_pid_ns(struct super_block *sb)
>{
> return proc_sb_info(sb)->pid_ns;
>}
>
>bool proc_ns_file(const struct file *file);
>
>extern int procfs_drop_fd_dentries;
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/nvmem-provider.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/nvmem-provider.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>struct device;
>struct gpio_desc;
>struct gpio_array;
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>struct gpio_descs {
> struct gpio_array *info;
> unsigned int ndescs;
> struct gpio_desc *desc[];
>};
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>enum gpiod_flags {
> GPIOD_ASIS = 0,
> GPIOD_IN = ((((1UL))) << (0)),
> GPIOD_OUT_LOW = ((((1UL))) << (0)) | ((((1UL))) << (1)),
> GPIOD_OUT_HIGH = ((((1UL))) << (0)) | ((((1UL))) << (1)) |
>     ((((1UL))) << (2)),
> GPIOD_OUT_LOW_OPEN_DRAIN = GPIOD_OUT_LOW | ((((1UL))) << (3)),
> GPIOD_OUT_HIGH_OPEN_DRAIN = GPIOD_OUT_HIGH | ((((1UL))) << (3)),
>};
>
>
>
>
>int gpiod_count(struct device *dev, const char *con_id);
>
>
>struct gpio_desc *__attribute__((__warn_unused_result__)) gpiod_get(struct device *dev,
>      const char *con_id,
>      enum gpiod_flags flags);
>struct gpio_desc *__attribute__((__warn_unused_result__)) gpiod_get_index(struct device *dev,
>            const char *con_id,
>            unsigned int idx,
>            enum gpiod_flags flags);
>struct gpio_desc *__attribute__((__warn_unused_result__)) gpiod_get_optional(struct device *dev,
>        const char *con_id,
>        enum gpiod_flags flags);
>struct gpio_desc *__attribute__((__warn_unused_result__)) gpiod_get_index_optional(struct device *dev,
>       const char *con_id,
>       unsigned int index,
>       enum gpiod_flags flags);
>struct gpio_descs *__attribute__((__warn_unused_result__)) gpiod_get_array(struct device *dev,
>      const char *con_id,
>      enum gpiod_flags flags);
>struct gpio_descs *__attribute__((__warn_unused_result__)) gpiod_get_array_optional(struct device *dev,
>       const char *con_id,
>       enum gpiod_flags flags);
>void gpiod_put(struct gpio_desc *desc);
>void gpiod_put_array(struct gpio_descs *descs);
>
>struct gpio_desc *__attribute__((__warn_unused_result__)) devm_gpiod_get(struct device *dev,
>           const char *con_id,
>           enum gpiod_flags flags);
>struct gpio_desc *__attribute__((__warn_unused_result__)) devm_gpiod_get_index(struct device *dev,
>          const char *con_id,
>          unsigned int idx,
>          enum gpiod_flags flags);
>struct gpio_desc *__attribute__((__warn_unused_result__)) devm_gpiod_get_optional(struct device *dev,
>             const char *con_id,
>             enum gpiod_flags flags);
>struct gpio_desc *__attribute__((__warn_unused_result__))
>devm_gpiod_get_index_optional(struct device *dev, const char *con_id,
>         unsigned int index, enum gpiod_flags flags);
>struct gpio_descs *__attribute__((__warn_unused_result__)) devm_gpiod_get_array(struct device *dev,
>           const char *con_id,
>           enum gpiod_flags flags);
>struct gpio_descs *__attribute__((__warn_unused_result__))
>devm_gpiod_get_array_optional(struct device *dev, const char *con_id,
>         enum gpiod_flags flags);
>void devm_gpiod_put(struct device *dev, struct gpio_desc *desc);
>void devm_gpiod_unhinge(struct device *dev, struct gpio_desc *desc);
>void devm_gpiod_put_array(struct device *dev, struct gpio_descs *descs);
>
>int gpiod_get_direction(struct gpio_desc *desc);
>int gpiod_direction_input(struct gpio_desc *desc);
>int gpiod_direction_output(struct gpio_desc *desc, int value);
>int gpiod_direction_output_raw(struct gpio_desc *desc, int value);
>
>
>int gpiod_get_value(const struct gpio_desc *desc);
>int gpiod_get_array_value(unsigned int array_size,
>     struct gpio_desc **desc_array,
>     struct gpio_array *array_info,
>     unsigned long *value_bitmap);
>void gpiod_set_value(struct gpio_desc *desc, int value);
>int gpiod_set_array_value(unsigned int array_size,
>     struct gpio_desc **desc_array,
>     struct gpio_array *array_info,
>     unsigned long *value_bitmap);
>int gpiod_get_raw_value(const struct gpio_desc *desc);
>int gpiod_get_raw_array_value(unsigned int array_size,
>         struct gpio_desc **desc_array,
>         struct gpio_array *array_info,
>         unsigned long *value_bitmap);
>void gpiod_set_raw_value(struct gpio_desc *desc, int value);
>int gpiod_set_raw_array_value(unsigned int array_size,
>         struct gpio_desc **desc_array,
>         struct gpio_array *array_info,
>         unsigned long *value_bitmap);
>
>
>int gpiod_get_value_cansleep(const struct gpio_desc *desc);
>int gpiod_get_array_value_cansleep(unsigned int array_size,
>       struct gpio_desc **desc_array,
>       struct gpio_array *array_info,
>       unsigned long *value_bitmap);
>void gpiod_set_value_cansleep(struct gpio_desc *desc, int value);
>int gpiod_set_array_value_cansleep(unsigned int array_size,
>       struct gpio_desc **desc_array,
>       struct gpio_array *array_info,
>       unsigned long *value_bitmap);
>int gpiod_get_raw_value_cansleep(const struct gpio_desc *desc);
>int gpiod_get_raw_array_value_cansleep(unsigned int array_size,
>           struct gpio_desc **desc_array,
>           struct gpio_array *array_info,
>           unsigned long *value_bitmap);
>void gpiod_set_raw_value_cansleep(struct gpio_desc *desc, int value);
>int gpiod_set_raw_array_value_cansleep(unsigned int array_size,
>           struct gpio_desc **desc_array,
>           struct gpio_array *array_info,
>           unsigned long *value_bitmap);
>
>int gpiod_set_config(struct gpio_desc *desc, unsigned long config);
>int gpiod_set_debounce(struct gpio_desc *desc, unsigned int debounce);
>int gpiod_set_transitory(struct gpio_desc *desc, bool transitory);
>void gpiod_toggle_active_low(struct gpio_desc *desc);
>
>int gpiod_is_active_low(const struct gpio_desc *desc);
>int gpiod_cansleep(const struct gpio_desc *desc);
>
>int gpiod_to_irq(const struct gpio_desc *desc);
>int gpiod_set_consumer_name(struct gpio_desc *desc, const char *name);
>
>
>struct gpio_desc *gpio_to_desc(unsigned gpio);
>int desc_to_gpio(const struct gpio_desc *desc);
>
>
>struct fwnode_handle;
>
>struct gpio_desc *fwnode_get_named_gpiod(struct fwnode_handle *fwnode,
>      const char *propname, int index,
>      enum gpiod_flags dflags,
>      const char *label);
>struct gpio_desc *fwnode_gpiod_get_index(struct fwnode_handle *fwnode,
>      const char *con_id, int index,
>      enum gpiod_flags flags,
>      const char *label);
>struct gpio_desc *devm_fwnode_gpiod_get_index(struct device *dev,
>           struct fwnode_handle *child,
>           const char *con_id, int index,
>           enum gpiod_flags flags,
>           const char *label);
># 574 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct gpio_desc *devm_fwnode_gpiod_get(struct device *dev,
>     struct fwnode_handle *fwnode,
>     const char *con_id,
>     enum gpiod_flags flags,
>     const char *label)
>{
> return devm_fwnode_gpiod_get_index(dev, fwnode, con_id, 0,
>        flags, label);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct gpio_desc *devm_fwnode_get_index_gpiod_from_child(struct device *dev,
>      const char *con_id, int index,
>      struct fwnode_handle *child,
>      enum gpiod_flags flags,
>      const char *label)
>{
> return devm_fwnode_gpiod_get_index(dev, child, con_id, index,
>        flags, label);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct gpio_desc *devm_fwnode_get_gpiod_from_child(struct device *dev,
>         const char *con_id,
>         struct fwnode_handle *child,
>         enum gpiod_flags flags,
>         const char *label)
>{
> return devm_fwnode_gpiod_get_index(dev, child, con_id, 0, flags, label);
>}
># 616 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>struct device_node;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct gpio_desc *gpiod_get_from_of_node(struct device_node *node,
>      const char *propname, int index,
>      enum gpiod_flags dflags,
>      const char *label)
>{
> return ERR_PTR(-38);
>}
>
>
>
>
>struct device_node;
>
>struct gpio_desc *devm_gpiod_get_from_of_node(struct device *dev,
>           struct device_node *node,
>           const char *propname, int index,
>           enum gpiod_flags dflags,
>           const char *label);
># 654 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>struct acpi_gpio_params {
> unsigned int crs_entry_index;
> unsigned int line_index;
> bool active_low;
>};
>
>struct acpi_gpio_mapping {
> const char *name;
> const struct acpi_gpio_params *data;
> unsigned int size;
># 677 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
> unsigned int quirks;
>};
>
>
>
>struct acpi_device;
>
>int acpi_dev_add_driver_gpios(struct acpi_device *adev,
>         const struct acpi_gpio_mapping *gpios);
>void acpi_dev_remove_driver_gpios(struct acpi_device *adev);
>
>int devm_acpi_dev_add_driver_gpios(struct device *dev,
>       const struct acpi_gpio_mapping *gpios);
>void devm_acpi_dev_remove_driver_gpios(struct device *dev);
>
>struct gpio_desc *acpi_get_and_request_gpiod(char *path, int pin, char *label);
># 717 "/usr/src/linux-5.14.21-150500.53/include/linux/gpio/consumer.h"
>int gpiod_export(struct gpio_desc *desc, bool direction_may_change);
>int gpiod_export_link(struct device *dev, const char *name,
>        struct gpio_desc *desc);
>void gpiod_unexport(struct gpio_desc *desc);
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/nvmem-provider.h" 2
>
>struct nvmem_device;
>struct nvmem_cell_info;
>typedef int (*nvmem_reg_read_t)(void *priv, unsigned int offset,
>    void *val, size_t bytes);
>typedef int (*nvmem_reg_write_t)(void *priv, unsigned int offset,
>     void *val, size_t bytes);
>
>enum nvmem_type {
> NVMEM_TYPE_UNKNOWN = 0,
> NVMEM_TYPE_EEPROM,
> NVMEM_TYPE_OTP,
> NVMEM_TYPE_BATTERY_BACKED,
> NVMEM_TYPE_FRAM,
>};
># 41 "/usr/src/linux-5.14.21-150500.53/include/linux/nvmem-provider.h"
>struct nvmem_keepout {
> unsigned int start;
> unsigned int end;
> unsigned char value;
>};
># 78 "/usr/src/linux-5.14.21-150500.53/include/linux/nvmem-provider.h"
>struct nvmem_config {
> struct device *dev;
> const char *name;
> int id;
> struct module *owner;
> struct gpio_desc *wp_gpio;
> const struct nvmem_cell_info *cells;
> int ncells;
> const struct nvmem_keepout *keepout;
> unsigned int nkeepout;
> enum nvmem_type type;
> bool read_only;
> bool root_only;
> struct device_node *of_node;
> bool no_of_node;
> nvmem_reg_read_t reg_read;
> nvmem_reg_write_t reg_write;
> int size;
> int word_size;
> int stride;
> void *priv;
>
> bool compat;
> struct device *base_dev;
>};
># 116 "/usr/src/linux-5.14.21-150500.53/include/linux/nvmem-provider.h"
>struct nvmem_cell_table {
> const char *nvmem_name;
> const struct nvmem_cell_info *cells;
> size_t ncells;
> struct list_head node;
>};
>
>
>
>struct nvmem_device *nvmem_register(const struct nvmem_config *cfg);
>void nvmem_unregister(struct nvmem_device *nvmem);
>
>struct nvmem_device *devm_nvmem_register(struct device *dev,
>      const struct nvmem_config *cfg);
>
>int devm_nvmem_unregister(struct device *dev, struct nvmem_device *nvmem);
>
>void nvmem_add_cell_table(struct nvmem_cell_table *table);
>void nvmem_del_cell_table(struct nvmem_cell_table *table);
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rtc.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rtc.h"
>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;
>};
># 59 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/rtc.h"
>struct rtc_pll_info {
> int pll_ctrl;
> int pll_value;
> int pll_max;
> int pll_min;
> int pll_posmult;
> int pll_negmult;
> long pll_clock;
>};
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h" 2
>
>extern int rtc_month_days(unsigned int month, unsigned int year);
>extern int rtc_year_days(unsigned int day, unsigned int month, unsigned int year);
>extern int rtc_valid_tm(struct rtc_time *tm);
>extern time64_t rtc_tm_to_time64(struct rtc_time *tm);
>extern void rtc_time64_to_tm(time64_t time, struct rtc_time *tm);
>ktime_t rtc_tm_to_ktime(struct rtc_time tm);
>struct rtc_time rtc_ktime_to_tm(ktime_t kt);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) time64_t rtc_tm_sub(struct rtc_time *lhs, struct rtc_time *rhs)
>{
> return rtc_tm_to_time64(lhs) - rtc_tm_to_time64(rhs);
>}
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>struct seq_operations;
>
>struct seq_file {
> char *buf;
> size_t size;
> size_t from;
> size_t count;
> size_t pad_until;
> loff_t index;
> loff_t read_pos;
> struct mutex lock;
> const struct seq_operations *op;
> int poll_event;
> const struct file *file;
> void *private;
>};
>
>struct seq_operations {
> void * (*start) (struct seq_file *m, loff_t *pos);
> void (*stop) (struct seq_file *m, void *v);
> void * (*next) (struct seq_file *m, void *v, loff_t *pos);
> int (*show) (struct seq_file *m, void *v);
>};
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool seq_has_overflowed(struct seq_file *m)
>{
> return m->count == m->size;
>}
># 63 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t seq_get_buf(struct seq_file *m, char **bufp)
>{
> do { if (__builtin_expect(!!(m->count > m->size), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"), "i" (65), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("309" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "309" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> if (m->count < m->size)
>  *bufp = m->buf + m->count;
> else
>  *bufp = ((void *)0);
>
> return m->size - m->count;
>}
># 83 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void seq_commit(struct seq_file *m, int num)
>{
> if (num < 0) {
>  m->count = m->size;
> } else {
>  do { if (__builtin_expect(!!(m->count + num > m->size), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"), "i" (88), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("310" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "310" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
>  m->count += num;
> }
>}
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void seq_setwidth(struct seq_file *m, size_t size)
>{
> m->pad_until = m->count + size;
>}
>void seq_pad(struct seq_file *m, char c);
>
>char *mangle_path(char *s, const char *p, const char *esc);
>int seq_open(struct file *, const struct seq_operations *);
>ssize_t seq_read(struct file *, char *, size_t, loff_t *);
>ssize_t seq_read_iter(struct kiocb *iocb, struct iov_iter *iter);
>loff_t seq_lseek(struct file *, loff_t, int);
>int seq_release(struct inode *, struct file *);
>int seq_write(struct seq_file *seq, const void *data, size_t len);
>
>__attribute__((__format__(printf, 2, 0)))
>void seq_vprintf(struct seq_file *m, const char *fmt, va_list args);
>__attribute__((__format__(printf, 2, 3)))
>void seq_printf(struct seq_file *m, const char *fmt, ...);
>void seq_putc(struct seq_file *m, char c);
>void seq_puts(struct seq_file *m, const char *s);
>void seq_put_decimal_ull_width(struct seq_file *m, const char *delimiter,
>          unsigned long long num, unsigned int width);
>void seq_put_decimal_ull(struct seq_file *m, const char *delimiter,
>    unsigned long long num);
>void seq_put_decimal_ll(struct seq_file *m, const char *delimiter, long long num);
>void seq_put_hex_ll(struct seq_file *m, const char *delimiter,
>      unsigned long long v, unsigned int width);
>
>void seq_escape_mem(struct seq_file *m, const char *src, size_t len,
>      unsigned int flags, const char *esc);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void seq_escape_str(struct seq_file *m, const char *src,
>      unsigned int flags, const char *esc)
>{
> seq_escape_mem(m, src, strlen(src), flags, esc);
>}
>
>void seq_escape(struct seq_file *m, const char *s, const char *esc);
>
>void seq_hex_dump(struct seq_file *m, const char *prefix_str, int prefix_type,
>    int rowsize, int groupsize, const void *buf, size_t len,
>    bool ascii);
>
>int seq_path(struct seq_file *, const struct path *, const char *);
>int seq_file_path(struct seq_file *, struct file *, const char *);
>int seq_dentry(struct seq_file *, struct dentry *, const char *);
>int seq_path_root(struct seq_file *m, const struct path *path,
>    const struct path *root, const char *esc);
>
>int single_open(struct file *, int (*)(struct seq_file *, void *), void *);
>int single_open_size(struct file *, int (*)(struct seq_file *, void *), void *, size_t);
>int single_release(struct inode *, struct file *);
>void *__seq_open_private(struct file *, const struct seq_operations *, int);
>int seq_open_private(struct file *, const struct seq_operations *, int);
>int seq_release_private(struct inode *, struct file *);
>
>
>void seq_bprintf(struct seq_file *m, const char *f, const u32 *binary);
># 207 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct user_namespace *seq_user_ns(struct seq_file *seq)
>{
>
> return seq->file->f_cred->user_ns;
>
>
>
>
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void seq_show_option(struct seq_file *m, const char *name,
>       const char *value)
>{
> seq_putc(m, ',');
> seq_escape(m, name, ",= \t\n\\");
> if (value) {
>  seq_putc(m, '=');
>  seq_escape(m, value, ", \t\n\\");
> }
>}
># 257 "/usr/src/linux-5.14.21-150500.53/include/linux/seq_file.h"
>extern struct list_head *seq_list_start(struct list_head *head,
>  loff_t pos);
>extern struct list_head *seq_list_start_head(struct list_head *head,
>  loff_t pos);
>extern struct list_head *seq_list_next(void *v, struct list_head *head,
>  loff_t *ppos);
>
>
>
>
>
>extern struct hlist_node *seq_hlist_start(struct hlist_head *head,
>       loff_t pos);
>extern struct hlist_node *seq_hlist_start_head(struct hlist_head *head,
>            loff_t pos);
>extern struct hlist_node *seq_hlist_next(void *v, struct hlist_head *head,
>      loff_t *ppos);
>
>extern struct hlist_node *seq_hlist_start_rcu(struct hlist_head *head,
>           loff_t pos);
>extern struct hlist_node *seq_hlist_start_head_rcu(struct hlist_head *head,
>         loff_t pos);
>extern struct hlist_node *seq_hlist_next_rcu(void *v,
>         struct hlist_head *head,
>         loff_t *ppos);
>
>
>extern struct hlist_node *seq_hlist_start_percpu(struct hlist_head *head, int *cpu, loff_t pos);
>
>extern struct hlist_node *seq_hlist_next_percpu(void *v, struct hlist_head *head, int *cpu, loff_t *pos);
>
>void seq_file_init(void);
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cdev.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/cdev.h"
>struct file_operations;
>struct inode;
>struct module;
>
>struct cdev {
> struct kobject kobj;
> struct module *owner;
> const struct file_operations *ops;
> struct list_head list;
> dev_t dev;
> unsigned int count;
>} __attribute__((__designated_init__));
>
>void cdev_init(struct cdev *, const struct file_operations *);
>
>struct cdev *cdev_alloc(void);
>
>void cdev_put(struct cdev *p);
>
>int cdev_add(struct cdev *, dev_t, unsigned);
>
>void cdev_set_parent(struct cdev *p, struct kobject *kobj);
>int cdev_device_add(struct cdev *cdev, struct device *dev);
>void cdev_device_del(struct cdev *cdev, struct device *dev);
>
>void cdev_del(struct cdev *);
>
>void cd_forget(struct inode *);
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h" 2
>
>
>
>
>
>extern struct class *rtc_class;
># 59 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
>struct rtc_class_ops {
> int (*ioctl)(struct device *, unsigned int, unsigned long);
> int (*read_time)(struct device *, struct rtc_time *);
> int (*set_time)(struct device *, struct rtc_time *);
> int (*read_alarm)(struct device *, struct rtc_wkalrm *);
> int (*set_alarm)(struct device *, struct rtc_wkalrm *);
> int (*proc)(struct device *, struct seq_file *);
> int (*alarm_irq_enable)(struct device *, unsigned int enabled);
> int (*read_offset)(struct device *, long *offset);
> int (*set_offset)(struct device *, long offset);
>};
>
>struct rtc_device;
>
>struct rtc_timer {
> struct timerqueue_node node;
> ktime_t period;
> void (*func)(struct rtc_device *rtc);
> struct rtc_device *rtc;
> int enabled;
>};
>
>
>
>
>struct rtc_device {
> struct device dev;
> struct module *owner;
>
> int id;
>
> const struct rtc_class_ops *ops;
> struct mutex ops_lock;
>
> struct cdev char_dev;
> unsigned long flags;
>
> unsigned long irq_data;
> spinlock_t irq_lock;
> wait_queue_head_t irq_queue;
> struct fasync_struct *async_queue;
>
> int irq_freq;
> int max_user_freq;
>
> struct timerqueue_head timerqueue;
> struct rtc_timer aie_timer;
> struct rtc_timer uie_rtctimer;
> struct hrtimer pie_timer;
> int pie_enabled;
> struct work_struct irqwork;
>
> int uie_unsupported;
># 142 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
> unsigned long set_offset_nsec;
>
> unsigned long features[(((3) + ((sizeof(long) * 8)) - 1) / ((sizeof(long) * 8)))];
>
> time64_t range_min;
> timeu64_t range_max;
> time64_t start_secs;
> time64_t offset_secs;
> bool set_start_time;
># 162 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
>};
># 178 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
>extern struct rtc_device *devm_rtc_device_register(struct device *dev,
>     const char *name,
>     const struct rtc_class_ops *ops,
>     struct module *owner);
>struct rtc_device *devm_rtc_allocate_device(struct device *dev);
>int __devm_rtc_register_device(struct module *owner, struct rtc_device *rtc);
>
>extern int rtc_read_time(struct rtc_device *rtc, struct rtc_time *tm);
>extern int rtc_set_time(struct rtc_device *rtc, struct rtc_time *tm);
>int __rtc_read_alarm(struct rtc_device *rtc, struct rtc_wkalrm *alarm);
>extern int rtc_read_alarm(struct rtc_device *rtc,
>   struct rtc_wkalrm *alrm);
>extern int rtc_set_alarm(struct rtc_device *rtc,
>    struct rtc_wkalrm *alrm);
>extern int rtc_initialize_alarm(struct rtc_device *rtc,
>    struct rtc_wkalrm *alrm);
>extern void rtc_update_irq(struct rtc_device *rtc,
>   unsigned long num, unsigned long events);
>
>extern struct rtc_device *rtc_class_open(const char *name);
>extern void rtc_class_close(struct rtc_device *rtc);
>
>extern int rtc_irq_set_state(struct rtc_device *rtc, int enabled);
>extern int rtc_irq_set_freq(struct rtc_device *rtc, int freq);
>extern int rtc_update_irq_enable(struct rtc_device *rtc, unsigned int enabled);
>extern int rtc_alarm_irq_enable(struct rtc_device *rtc, unsigned int enabled);
>extern int rtc_dev_update_irq_enable_emul(struct rtc_device *rtc,
>      unsigned int enabled);
>
>void rtc_handle_legacy_irq(struct rtc_device *rtc, int num, int mode);
>void rtc_aie_update_irq(struct rtc_device *rtc);
>void rtc_uie_update_irq(struct rtc_device *rtc);
>enum hrtimer_restart rtc_pie_update_irq(struct hrtimer *timer);
>
>void rtc_timer_init(struct rtc_timer *timer, void (*f)(struct rtc_device *r),
>      struct rtc_device *rtc);
>int rtc_timer_start(struct rtc_device *rtc, struct rtc_timer *timer,
>      ktime_t expires, ktime_t period);
>void rtc_timer_cancel(struct rtc_device *rtc, struct rtc_timer *timer);
>int rtc_read_offset(struct rtc_device *rtc, long *offset);
>int rtc_set_offset(struct rtc_device *rtc, long offset);
>void rtc_timer_do_work(struct work_struct *work);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_leap_year(unsigned int year)
>{
> return (!(year % 4) && (year % 100)) || !(year % 400);
>}
># 236 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
>int devm_rtc_nvmem_register(struct rtc_device *rtc,
>       struct nvmem_config *nvmem_config);
># 247 "/usr/src/linux-5.14.21-150500.53/include/linux/rtc.h"
>int rtc_add_group(struct rtc_device *rtc, const struct attribute_group *grp);
>int rtc_add_groups(struct rtc_device *rtc, const struct attribute_group **grps);
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pstore.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/pstore.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kmsg_dump.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/kmsg_dump.h"
>enum kmsg_dump_reason {
> KMSG_DUMP_UNDEF,
> KMSG_DUMP_PANIC,
> KMSG_DUMP_OOPS,
> KMSG_DUMP_EMERG,
> KMSG_DUMP_SHUTDOWN,
> KMSG_DUMP_MAX
>};
>
>
>
>
>
>
>struct kmsg_dump_iter {
> u64 cur_seq;
> u64 next_seq;
>};
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/kmsg_dump.h"
>struct kmsg_dumper {
> struct list_head list;
> void (*dump)(struct kmsg_dumper *dumper, enum kmsg_dump_reason reason);
> enum kmsg_dump_reason max_reason;
> bool registered;
>};
>
>
>void kmsg_dump(enum kmsg_dump_reason reason);
>
>bool kmsg_dump_get_line(struct kmsg_dump_iter *iter, bool syslog,
>   char *line, size_t size, size_t *len);
>
>bool kmsg_dump_get_buffer(struct kmsg_dump_iter *iter, bool syslog,
>     char *buf, size_t size, size_t *len_out);
>
>void kmsg_dump_rewind(struct kmsg_dump_iter *iter);
>
>int kmsg_dump_register(struct kmsg_dumper *dumper);
>
>int kmsg_dump_unregister(struct kmsg_dumper *dumper);
>
>const char *kmsg_dump_reason_str(enum kmsg_dump_reason reason);
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/pstore.h" 2
>
>
>
>
>
>struct module;
>
>
>
>
>
>
>enum pstore_type_id {
>
> PSTORE_TYPE_DMESG = 0,
> PSTORE_TYPE_MCE = 1,
> PSTORE_TYPE_CONSOLE = 2,
> PSTORE_TYPE_FTRACE = 3,
>
>
> PSTORE_TYPE_PPC_RTAS = 4,
> PSTORE_TYPE_PPC_OF = 5,
> PSTORE_TYPE_PPC_COMMON = 6,
> PSTORE_TYPE_PMSG = 7,
> PSTORE_TYPE_PPC_OPAL = 8,
>
>
> PSTORE_TYPE_MAX
>};
>
>const char *pstore_type_to_name(enum pstore_type_id type);
>enum pstore_type_id pstore_name_to_type(const char *name);
>
>struct pstore_info;
># 72 "/usr/src/linux-5.14.21-150500.53/include/linux/pstore.h"
>struct pstore_record {
> struct pstore_info *psi;
> enum pstore_type_id type;
> u64 id;
> struct timespec64 time;
> char *buf;
> ssize_t size;
> ssize_t ecc_notice_size;
> void *priv;
>
> int count;
> enum kmsg_dump_reason reason;
> unsigned int part;
> bool compressed;
>};
># 181 "/usr/src/linux-5.14.21-150500.53/include/linux/pstore.h"
>struct pstore_info {
> struct module *owner;
> const char *name;
>
> spinlock_t buf_lock;
> char *buf;
> size_t bufsize;
>
> struct mutex read_mutex;
>
> int flags;
> int max_reason;
> void *data;
>
> int (*open)(struct pstore_info *psi);
> int (*close)(struct pstore_info *psi);
> ssize_t (*read)(struct pstore_record *record);
> int (*write)(struct pstore_record *record);
> int (*write_user)(struct pstore_record *record,
>          const char *buf);
> int (*erase)(struct pstore_record *record);
>};
>
>
>
>
>
>
>
>extern int pstore_register(struct pstore_info *);
>extern void pstore_unregister(struct pstore_info *);
>
>struct pstore_ftrace_record {
> unsigned long ip;
> unsigned long parent_ip;
> u64 ts;
>};
># 263 "/usr/src/linux-5.14.21-150500.53/include/linux/pstore.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pstore_ftrace_encode_cpu(struct pstore_ftrace_record *rec, unsigned int cpu)
>{
> rec->ts &= ~((((((1UL))) << (8)) - 1));
> rec->ts |= cpu;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int
>pstore_ftrace_decode_cpu(struct pstore_ftrace_record *rec)
>{
> return rec->ts & (((((1UL))) << (8)) - 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64
>pstore_ftrace_read_timestamp(struct pstore_ftrace_record *rec)
>{
> return rec->ts >> 8;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>pstore_ftrace_write_timestamp(struct pstore_ftrace_record *rec, u64 val)
>{
> rec->ts = (rec->ts & (((((1UL))) << (8)) - 1)) | (val << 8);
>}
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/reboot.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/reboot.h" 1
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/reboot.h" 2
>
>struct device;
>
>
>
>
>
>
>enum reboot_mode {
> REBOOT_UNDEFINED = -1,
> REBOOT_COLD = 0,
> REBOOT_WARM,
> REBOOT_HARD,
> REBOOT_SOFT,
> REBOOT_GPIO,
>};
>extern enum reboot_mode reboot_mode;
>extern enum reboot_mode panic_reboot_mode;
>
>enum reboot_type {
> BOOT_TRIPLE = 't',
> BOOT_KBD = 'k',
> BOOT_BIOS = 'b',
> BOOT_ACPI = 'a',
> BOOT_EFI = 'e',
> BOOT_CF9_FORCE = 'p',
> BOOT_CF9_SAFE = 'q',
>};
>extern enum reboot_type reboot_type;
>
>extern int reboot_default;
>extern int reboot_cpu;
>extern int reboot_force;
>
>
>extern int register_reboot_notifier(struct notifier_block *);
>extern int unregister_reboot_notifier(struct notifier_block *);
>
>extern int devm_register_reboot_notifier(struct device *, struct notifier_block *);
>
>extern int register_restart_handler(struct notifier_block *);
>extern int unregister_restart_handler(struct notifier_block *);
>extern void do_kernel_restart(char *cmd);
>
>
>
>
>
>extern void migrate_to_reboot_cpu(void);
>extern void machine_restart(char *cmd);
>extern void machine_halt(void);
>extern void machine_power_off(void);
>
>extern void machine_shutdown(void);
>struct pt_regs;
>extern void machine_crash_shutdown(struct pt_regs *);
>
>
>
>
>
>extern void kernel_restart_prepare(char *cmd);
>extern void kernel_restart(char *cmd);
>extern void kernel_halt(void);
>extern void kernel_power_off(void);
>
>extern int C_A_D;
>void ctrl_alt_del(void);
>
>
>extern char poweroff_cmd[256];
>
>extern void orderly_poweroff(bool force);
>extern void orderly_reboot(void);
>void hw_protection_shutdown(const char *reason, int ms_until_forced);
>
>
>
>
>
>extern void emergency_restart(void);
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/emergency-restart.h" 1
>
>
>
>
>extern void machine_emergency_restart(void);
># 90 "/usr/src/linux-5.14.21-150500.53/include/linux/reboot.h" 2
># 26 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h" 2
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef unsigned long efi_status_t;
>typedef u8 efi_bool_t;
>typedef u16 efi_char16_t;
>typedef u64 efi_physical_addr_t;
>typedef void *efi_handle_t;
># 73 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef guid_t efi_guid_t __attribute__((__aligned__(__alignof__(u32))));
># 83 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef struct {
> u64 signature;
> u32 revision;
> u32 headersize;
> u32 crc32;
> u32 reserved;
>} efi_table_hdr_t;
># 135 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef struct {
> u32 type;
> u32 pad;
> u64 phys_addr;
> u64 virt_addr;
> u64 num_pages;
> u64 attribute;
>} efi_memory_desc_t;
>
>typedef struct {
> efi_guid_t guid;
> u32 headersize;
> u32 flags;
> u32 imagesize;
>} efi_capsule_header_t;
>
>
>struct efi_manage_capsule_header {
> u32 ver;
> u16 emb_drv_cnt;
> u16 payload_cnt;
>
>
>
>
> u64 offset_list[];
>} __attribute__((__packed__));
>
>
>struct efi_manage_capsule_image_header {
> u32 ver;
> efi_guid_t image_type_id;
> u8 image_index;
> u8 reserved_bytes[3];
> u32 image_size;
> u32 vendor_code_size;
>
> u64 hw_ins;
>
> u64 capsule_support;
>} __attribute__((__packed__));
>
>
>struct win_cert {
> u32 len;
> u16 rev;
> u16 cert_type;
>};
>
>
>struct win_cert_uefi_guid {
> struct win_cert hdr;
> efi_guid_t cert_type;
> u8 cert_data[];
>};
>
>
>struct efi_image_auth {
> u64 mon_count;
> struct win_cert_uefi_guid auth_info;
>};
># 204 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>struct capsule_info {
> efi_capsule_header_t header;
> efi_capsule_header_t *capsule;
> int reset_type;
> long index;
> size_t count;
> size_t total_size;
> struct page **pages;
> phys_addr_t *phys;
> size_t page_bytes_remain;
>};
>
>int efi_capsule_setup_info(struct capsule_info *cap_info, void *kbuff,
>                           size_t hdr_bytes);
>int __efi_capsule_setup_info(struct capsule_info *cap_info);
># 227 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef struct {
> u16 year;
> u8 month;
> u8 day;
> u8 hour;
> u8 minute;
> u8 second;
> u8 pad1;
> u32 nanosecond;
> s16 timezone;
> u8 daylight;
> u8 pad2;
>} efi_time_t;
>
>typedef struct {
> u32 resolution;
> u32 accuracy;
> u8 sets_to_zero;
>} efi_time_cap_t;
>
>typedef union efi_boot_services efi_boot_services_t;
># 262 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>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 efi_status_t efi_get_time_t (efi_time_t *tm, efi_time_cap_t *tc);
>typedef efi_status_t efi_set_time_t (efi_time_t *tm);
>typedef efi_status_t efi_get_wakeup_time_t (efi_bool_t *enabled, efi_bool_t *pending,
>         efi_time_t *tm);
>typedef efi_status_t efi_set_wakeup_time_t (efi_bool_t enabled, efi_time_t *tm);
>typedef efi_status_t efi_get_variable_t (efi_char16_t *name, efi_guid_t *vendor, u32 *attr,
>      unsigned long *data_size, void *data);
>typedef efi_status_t efi_get_next_variable_t (unsigned long *name_size, efi_char16_t *name,
>           efi_guid_t *vendor);
>typedef efi_status_t efi_set_variable_t (efi_char16_t *name, efi_guid_t *vendor,
>      u32 attr, unsigned long data_size,
>      void *data);
>typedef efi_status_t efi_get_next_high_mono_count_t (u32 *count);
>typedef void efi_reset_system_t (int reset_type, efi_status_t status,
>     unsigned long data_size, efi_char16_t *data);
>typedef efi_status_t efi_set_virtual_address_map_t (unsigned long memory_map_size,
>      unsigned long descriptor_size,
>      u32 descriptor_version,
>      efi_memory_desc_t *virtual_map);
>typedef efi_status_t efi_query_variable_info_t(u32 attr,
>            u64 *storage_space,
>            u64 *remaining_space,
>            u64 *max_variable_size);
>typedef efi_status_t efi_update_capsule_t(efi_capsule_header_t **capsules,
>       unsigned long count,
>       unsigned long sg_list);
>typedef efi_status_t efi_query_capsule_caps_t(efi_capsule_header_t **capsules,
>           unsigned long count,
>           u64 *max_size,
>           int *reset_type);
>typedef efi_status_t efi_query_variable_store_t(u32 attributes,
>      unsigned long size,
>      bool nonblocking);
>
>typedef union {
> struct {
>  efi_table_hdr_t hdr;
>  efi_get_time_t __attribute__((ms_abi)) *get_time;
>  efi_set_time_t __attribute__((ms_abi)) *set_time;
>  efi_get_wakeup_time_t __attribute__((ms_abi)) *get_wakeup_time;
>  efi_set_wakeup_time_t __attribute__((ms_abi)) *set_wakeup_time;
>  efi_set_virtual_address_map_t __attribute__((ms_abi)) *set_virtual_address_map;
>  void *convert_pointer;
>  efi_get_variable_t __attribute__((ms_abi)) *get_variable;
>  efi_get_next_variable_t __attribute__((ms_abi)) *get_next_variable;
>  efi_set_variable_t __attribute__((ms_abi)) *set_variable;
>  efi_get_next_high_mono_count_t __attribute__((ms_abi)) *get_next_high_mono_count;
>  efi_reset_system_t __attribute__((ms_abi)) *reset_system;
>  efi_update_capsule_t __attribute__((ms_abi)) *update_capsule;
>  efi_query_capsule_caps_t __attribute__((ms_abi)) *query_capsule_caps;
>  efi_query_variable_info_t __attribute__((ms_abi)) *query_variable_info;
> };
> efi_runtime_services_32_t mixed_mode;
>} efi_runtime_services_t;
>
>void efi_native_runtime_setup(void);
># 429 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef struct {
> efi_guid_t guid;
> u64 table;
>} efi_config_table_64_t;
>
>typedef struct {
> efi_guid_t guid;
> u32 table;
>} efi_config_table_32_t;
>
>typedef union {
> struct {
>  efi_guid_t guid;
>  void *table;
> };
> efi_config_table_32_t mixed_mode;
>} efi_config_table_t;
>
>typedef struct {
> efi_guid_t guid;
> unsigned long *ptr;
> const char name[16];
>} efi_config_table_type_t;
># 463 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>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;
> 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 union efi_simple_text_input_protocol efi_simple_text_input_protocol_t;
>typedef union efi_simple_text_output_protocol efi_simple_text_output_protocol_t;
>
>typedef union {
> struct {
>  efi_table_hdr_t hdr;
>  unsigned long fw_vendor;
>  u32 fw_revision;
>  unsigned long con_in_handle;
>  efi_simple_text_input_protocol_t *con_in;
>  unsigned long con_out_handle;
>  efi_simple_text_output_protocol_t *con_out;
>  unsigned long stderr_handle;
>  unsigned long stderr;
>  efi_runtime_services_t *runtime;
>  efi_boot_services_t *boottime;
>  unsigned long nr_tables;
>  unsigned long tables;
> };
> efi_system_table_32_t mixed_mode;
>} efi_system_table_t;
>
>
>
>
>
>
>struct efi_memory_map_data {
> phys_addr_t phys_map;
> unsigned long size;
> unsigned long desc_version;
> unsigned long desc_size;
> unsigned long flags;
>};
>
>struct efi_memory_map {
> phys_addr_t phys_map;
> void *map;
> void *map_end;
> int nr_map;
> unsigned long desc_version;
> unsigned long desc_size;
>
>
>
> unsigned long flags;
>};
>
>struct efi_mem_range {
> struct range range;
> u64 attribute;
>};
>
>typedef struct {
> u32 version;
> u32 length;
> u64 memory_protection_attribute;
>} efi_properties_table_t;
>
>
>
>
>typedef struct {
> u16 version;
> u16 length;
> u32 runtime_services_supported;
>} efi_rt_properties_table_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 {
> efi_guid_t signature_owner;
> u8 signature_data[];
>} efi_signature_data_t;
>
>typedef struct {
> efi_guid_t signature_type;
> u32 signature_list_size;
> u32 signature_header_size;
> u32 signature_size;
> u8 signature_header[];
>
>} efi_signature_list_t;
>
>typedef u8 efi_sha256_hash_t[32];
>
>typedef struct {
> efi_sha256_hash_t to_be_signed_hash;
> efi_time_t time_of_revocation;
>} efi_cert_x509_sha256_t;
>
>extern unsigned long __attribute__((__section__(".data..ro_after_init"))) efi_rng_seed;
>
>
>
>
>extern struct efi {
> const efi_runtime_services_t *runtime;
> unsigned int runtime_version;
> unsigned int runtime_supported_mask;
>
> unsigned long acpi;
> unsigned long acpi20;
> unsigned long smbios;
> unsigned long smbios3;
> unsigned long esrt;
> unsigned long tpm_log;
> unsigned long tpm_final_log;
> unsigned long mokvar_table;
> unsigned long coco_secret;
>
> efi_get_time_t *get_time;
> efi_set_time_t *set_time;
> efi_get_wakeup_time_t *get_wakeup_time;
> efi_set_wakeup_time_t *set_wakeup_time;
> efi_get_variable_t *get_variable;
> efi_get_next_variable_t *get_next_variable;
> efi_set_variable_t *set_variable;
> efi_set_variable_t *set_variable_nonblocking;
> efi_query_variable_info_t *query_variable_info;
> efi_query_variable_info_t *query_variable_info_nonblocking;
> efi_update_capsule_t *update_capsule;
> efi_query_capsule_caps_t *query_capsule_caps;
> efi_get_next_high_mono_count_t *get_next_high_mono_count;
> efi_reset_system_t *reset_system;
>
> struct efi_memory_map memmap;
> unsigned long flags;
>} efi;
># 657 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>extern struct mm_struct efi_mm;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>efi_guidcmp (efi_guid_t left, efi_guid_t right)
>{
> return memcmp(&left, &right, sizeof (efi_guid_t));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) char *
>efi_guid_to_str(efi_guid_t *guid, char *out)
>{
> sprintf(out, "%pUl", guid->b);
>        return out;
>}
>
>extern void efi_init (void);
>
>extern void efi_enter_virtual_mode (void);
>
>
>
>
>extern efi_status_t efi_query_variable_store(u32 attributes,
>          unsigned long size,
>          bool nonblocking);
># 691 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>extern void *efi_lookup_mapped_addr(u64 phys_addr);
>
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_alloc(unsigned int num_entries,
>       struct efi_memory_map_data *data);
>extern void __efi_memmap_free(u64 phys, unsigned long size,
>         unsigned long flags);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_init_early(struct efi_memory_map_data *data);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_init_late(phys_addr_t addr, unsigned long size);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_unmap(void);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_install(struct efi_memory_map_data *data);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_split_count(efi_memory_desc_t *md,
>      struct range *range);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_memmap_insert(struct efi_memory_map *old_memmap,
>         void *buf, struct efi_mem_range *mem);
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_esrt_init(void);
>
>
>
>extern int efi_config_parse_tables(const efi_config_table_t *config_tables,
>       int count,
>       const efi_config_table_type_t *arch_tables);
>extern int efi_systab_check_header(const efi_table_hdr_t *systab_hdr,
>       int min_major_version);
>extern void efi_systab_report_header(const efi_table_hdr_t *systab_hdr,
>         unsigned long fw_vendor);
>extern u64 efi_get_iobase (void);
>extern int efi_mem_type(unsigned long phys_addr);
>extern u64 efi_mem_attributes (unsigned long phys_addr);
>extern u64 efi_mem_attribute (unsigned long phys_addr, unsigned long size);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_uart_console_only (void);
>extern u64 efi_mem_desc_end(efi_memory_desc_t *md);
>extern int efi_mem_desc_lookup(u64 phys_addr, efi_memory_desc_t *out_md);
>extern void efi_mem_reserve(phys_addr_t addr, u64 size);
>extern int efi_mem_reserve_persistent(phys_addr_t addr, u64 size);
>extern void efi_initialize_iomem_resources(struct resource *code_resource,
>  struct resource *data_resource, struct resource *bss_resource);
>extern u64 efi_get_fdt_params(struct efi_memory_map_data *data);
>extern struct kobject *efi_kobj;
>
>extern int efi_reboot_quirk_mode;
>extern bool efi_poweroff_required(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void efi_fake_memmap(void) { }
>
>
>extern unsigned long efi_mem_attr_table;
># 750 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>typedef int (*efi_memattr_perm_setter)(struct mm_struct *, efi_memory_desc_t *);
>
>extern int efi_memattr_init(void);
>extern int efi_memattr_apply_permissions(struct mm_struct *mm,
>      efi_memattr_perm_setter fn);
># 797 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>char * __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_md_typeattr_format(char *buf, size_t size,
>         const efi_memory_desc_t *md);
>
>
>typedef void (*efi_element_handler_t)(const char *source,
>          const void *element_data,
>          size_t element_size);
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) parse_efi_signature_list(
> const char *source,
> const void *data, size_t size,
> efi_element_handler_t (*get_handler_for_guid)(const efi_guid_t *));
># 817 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int efi_range_is_wc(unsigned long start, unsigned long len)
>{
> unsigned long i;
>
> for (i = 0; i < len; i += (1UL << 12)) {
>  unsigned long paddr = __phys_addr_nodebug((unsigned long)(start + i));
>  if (!(efi_mem_attributes(paddr) & ((u64)0x0000000000000002ULL)))
>   return 0;
> }
>
> return 1;
>}
># 852 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>enum efi_secureboot_mode {
> efi_secureboot_mode_unset,
> efi_secureboot_mode_unknown,
> efi_secureboot_mode_disabled,
> efi_secureboot_mode_enabled,
>};
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool efi_enabled(int feature)
>{
> return test_bit(feature, &efi.flags) != 0;
>}
>extern void efi_reboot(enum reboot_mode reboot_mode, const char *__unused);
>
>bool __attribute__((__pure__)) __efi_soft_reserve_enabled(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __attribute__((__pure__)) efi_soft_reserve_enabled(void)
>{
> return 1
>  && __efi_soft_reserve_enabled();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool efi_rt_services_supported(unsigned int mask)
>{
> return (efi.runtime_supported_mask & mask) == mask;
>}
>extern void efi_find_mirror(void);
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_set_secure_boot(enum efi_secureboot_mode mode);
># 907 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>extern int efi_status_to_err(efi_status_t status);
># 971 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>struct efi_generic_dev_path {
> u8 type;
> u8 sub_type;
> u16 length;
>} __attribute__((__packed__));
>
>struct efi_acpi_dev_path {
> struct efi_generic_dev_path header;
> u32 hid;
> u32 uid;
>} __attribute__((__packed__));
>
>struct efi_pci_dev_path {
> struct efi_generic_dev_path header;
> u8 fn;
> u8 dev;
>} __attribute__((__packed__));
>
>struct efi_vendor_dev_path {
> struct efi_generic_dev_path header;
> efi_guid_t vendorguid;
> u8 vendordata[];
>} __attribute__((__packed__));
>
>struct efi_dev_path {
> union {
>  struct efi_generic_dev_path header;
>  struct efi_acpi_dev_path acpi;
>  struct efi_pci_dev_path pci;
>  struct efi_vendor_dev_path vendor;
> };
>} __attribute__((__packed__));
>
>struct device *efi_get_device_by_path(const struct efi_dev_path **node,
>          size_t *len);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memrange_efi_to_native(u64 *addr, u64 *npages)
>{
> *npages = (((*addr + (*npages<<12)) + ((1UL) << 12)-1) >> 12) - ((*addr) >> 12);
> *addr &= (~(((1UL) << 12)-1));
>}
># 1020 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>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 {
> struct kset *kset;
> struct kobject *kobject;
> const struct efivar_operations *ops;
>};
># 1043 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>int efivars_register(struct efivars *efivars,
>       const struct efivar_operations *ops,
>       struct kobject *kobject);
>int efivars_unregister(struct efivars *efivars);
>struct kobject *efivars_kobject(void);
>
>int efivar_supports_writes(void);
>
>int efivar_lock(void);
>int efivar_trylock(void);
>void efivar_unlock(void);
>
>efi_status_t efivar_get_variable(efi_char16_t *name, efi_guid_t *vendor,
>     u32 *attr, unsigned long *size, void *data);
>
>efi_status_t efivar_get_next_variable(unsigned long *name_size,
>          efi_char16_t *name, efi_guid_t *vendor);
>
>efi_status_t efivar_set_variable_locked(efi_char16_t *name, efi_guid_t *vendor,
>     u32 attr, unsigned long data_size,
>     void *data, bool nonblocking);
>
>efi_status_t efivar_set_variable(efi_char16_t *name, efi_guid_t *vendor,
>     u32 attr, unsigned long data_size, void *data);
>
>efi_status_t check_var_size(u32 attributes, unsigned long size);
>efi_status_t check_var_size_nonblocking(u32 attributes, unsigned long size);
>
>
>extern bool efi_capsule_pending(int *reset_type);
>
>extern int efi_capsule_supported(efi_guid_t guid, u32 flags,
>     size_t size, int *reset);
>
>extern int efi_capsule_update(efi_capsule_header_t *capsule,
>         phys_addr_t *pages);
>
>
>
>
>
>int efi_runtime_map_init(struct kobject *);
>int efi_get_runtime_map_size(void);
>int efi_get_runtime_map_desc_size(void);
>int efi_runtime_map_copy(void *buf, size_t bufsz);
># 1112 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>extern bool efi_runtime_disabled(void);
>
>
>
>
>extern void efi_call_virt_check_flags(unsigned long flags, const char *call);
>extern unsigned long efi_call_virt_save_flags(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>enum efi_secureboot_mode efi_get_secureboot_mode(efi_get_variable_t *get_var)
>{
> u8 secboot, setupmode = 0;
> efi_status_t status;
> unsigned long size;
>
> size = sizeof(secboot);
> status = get_var(L"SecureBoot", &(efi_guid_t){ { (0x8be4df61) & 0xff, ((0x8be4df61) >> 8) & 0xff, ((0x8be4df61) >> 16) & 0xff, ((0x8be4df61) >> 24) & 0xff, (0x93ca) & 0xff, ((0x93ca) >> 8) & 0xff, (0x11d2) & 0xff, ((0x11d2) >> 8) & 0xff, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c } }, ((void *)0), &size,
>    &secboot);
> if (status == (14 | (1UL << (64 -1))))
>  return efi_secureboot_mode_disabled;
> if (status != 0)
>  return efi_secureboot_mode_unknown;
>
> size = sizeof(setupmode);
> get_var(L"SetupMode", &(efi_guid_t){ { (0x8be4df61) & 0xff, ((0x8be4df61) >> 8) & 0xff, ((0x8be4df61) >> 16) & 0xff, ((0x8be4df61) >> 24) & 0xff, (0x93ca) & 0xff, ((0x93ca) >> 8) & 0xff, (0x11d2) & 0xff, ((0x11d2) >> 8) & 0xff, 0xaa, 0x0d, 0x00, 0xe0, 0x98, 0x03, 0x2b, 0x8c } }, ((void *)0), &size, &setupmode);
> if (secboot == 0 || setupmode == 1)
>  return efi_secureboot_mode_disabled;
> return efi_secureboot_mode_enabled;
>}
>
>
>void efi_check_for_embedded_firmwares(void);
>
>
>
>
>efi_status_t efi_random_get_seed(void);
># 1203 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>struct linux_efi_random_seed {
> u32 size;
> u8 bits[];
>};
>
>struct linux_efi_tpm_eventlog {
> u32 size;
> u32 final_events_preboot_size;
> u8 version;
> u8 log[];
>};
>
>extern int efi_tpm_eventlog_init(void);
>
>struct efi_tcg2_final_events_table {
> u64 version;
> u64 nr_events;
> u8 events[];
>};
>extern int efi_tpm_final_log_size;
>
>extern unsigned long rci2_table_phys;
>
>
>
>
>
>
>enum efi_rts_ids {
> EFI_NONE,
> EFI_GET_TIME,
> EFI_SET_TIME,
> EFI_GET_WAKEUP_TIME,
> EFI_SET_WAKEUP_TIME,
> EFI_GET_VARIABLE,
> EFI_GET_NEXT_VARIABLE,
> EFI_SET_VARIABLE,
> EFI_QUERY_VARIABLE_INFO,
> EFI_GET_NEXT_HIGH_MONO_COUNT,
> EFI_RESET_SYSTEM,
> EFI_UPDATE_CAPSULE,
> EFI_QUERY_CAPSULE_CAPS,
>};
># 1254 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>struct efi_runtime_work {
> void *arg1;
> void *arg2;
> void *arg3;
> void *arg4;
> void *arg5;
> efi_status_t status;
> struct work_struct work;
> enum efi_rts_ids efi_rts_id;
> struct completion efi_rts_comp;
>};
>
>extern struct efi_runtime_work efi_rts_work;
>
>
>extern struct workqueue_struct *efi_rts_wq;
>
>struct linux_efi_memreserve {
> int size;
> atomic_t count;
> phys_addr_t next;
> struct {
>  phys_addr_t base;
>  phys_addr_t size;
> } entry[];
>};
>
>
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_arch_mem_reserve(phys_addr_t addr, u64 size);
>
>char *efi_systab_show_arch(char *str);
># 1295 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>struct efi_mokvar_table_entry {
> char name[256];
> u64 data_size;
> u8 data[];
>} __attribute((packed));
>
>
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) efi_mokvar_table_init(void);
>extern struct efi_mokvar_table_entry *efi_mokvar_entry_next(
>   struct efi_mokvar_table_entry **mokvar_entry);
>extern struct efi_mokvar_table_entry *efi_mokvar_entry_find(const char *name);
># 1320 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>extern void efifb_setup_from_dmi(struct screen_info *si, const char *opt);
>
>struct linux_efi_coco_secret_area {
> u64 base_pa;
> u64 size;
>};
># 1339 "/usr/src/linux-5.14.21-150500.53/include/linux/efi.h"
>struct efi_skey_setup_data {
> unsigned long detect_status;
> unsigned long final_status;
> unsigned long key_size;
> u8 secret_key[64];
>};
>extern void *get_efi_secret_key(void);
>extern void efi_skey_stop_regen(void);
>extern void efi_skey_set_regen(void);
>extern int efi_skey_sysfs_init(struct kobject *efi_kobj);
># 200 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 293 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-procfs.h" 1
># 32 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-procfs.h"
>typedef struct proc_ops nv_proc_ops_t;
># 294 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 318 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>extern int nv_pat_mode;
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h" 1
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/irqhandler.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/irqhandler.h"
>struct irq_desc;
>struct irq_data;
>typedef void (*irq_flow_handler_t)(struct irq_desc *desc);
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h"
>struct device;
>struct net_device;
>
>enum dev_prop_type {
> DEV_PROP_U8,
> DEV_PROP_U16,
> DEV_PROP_U32,
> DEV_PROP_U64,
> DEV_PROP_STRING,
> DEV_PROP_REF,
>};
>
>enum dev_dma_attr {
> DEV_DMA_NOT_SUPPORTED,
> DEV_DMA_NON_COHERENT,
> DEV_DMA_COHERENT,
>};
>
>struct fwnode_handle *dev_fwnode(struct device *dev);
>
>bool device_property_present(struct device *dev, const char *propname);
>int device_property_read_u8_array(struct device *dev, const char *propname,
>      u8 *val, size_t nval);
>int device_property_read_u16_array(struct device *dev, const char *propname,
>       u16 *val, size_t nval);
>int device_property_read_u32_array(struct device *dev, const char *propname,
>       u32 *val, size_t nval);
>int device_property_read_u64_array(struct device *dev, const char *propname,
>       u64 *val, size_t nval);
>int device_property_read_string_array(struct device *dev, const char *propname,
>          const char **val, size_t nval);
>int device_property_read_string(struct device *dev, const char *propname,
>    const char **val);
>int device_property_match_string(struct device *dev,
>     const char *propname, const char *string);
>
>bool fwnode_device_is_available(const struct fwnode_handle *fwnode);
>bool fwnode_property_present(const struct fwnode_handle *fwnode,
>        const char *propname);
>int fwnode_property_read_u8_array(const struct fwnode_handle *fwnode,
>      const char *propname, u8 *val,
>      size_t nval);
>int fwnode_property_read_u16_array(const struct fwnode_handle *fwnode,
>       const char *propname, u16 *val,
>       size_t nval);
>int fwnode_property_read_u32_array(const struct fwnode_handle *fwnode,
>       const char *propname, u32 *val,
>       size_t nval);
>int fwnode_property_read_u64_array(const struct fwnode_handle *fwnode,
>       const char *propname, u64 *val,
>       size_t nval);
>int fwnode_property_read_string_array(const struct fwnode_handle *fwnode,
>          const char *propname, const char **val,
>          size_t nval);
>int fwnode_property_read_string(const struct fwnode_handle *fwnode,
>    const char *propname, const char **val);
>int fwnode_property_match_string(const struct fwnode_handle *fwnode,
>     const char *propname, const char *string);
>int fwnode_property_get_reference_args(const struct fwnode_handle *fwnode,
>           const char *prop, const char *nargs_prop,
>           unsigned int nargs, unsigned int index,
>           struct fwnode_reference_args *args);
>
>struct fwnode_handle *fwnode_find_reference(const struct fwnode_handle *fwnode,
>         const char *name,
>         unsigned int index);
>
>const char *fwnode_get_name(const struct fwnode_handle *fwnode);
>const char *fwnode_get_name_prefix(const struct fwnode_handle *fwnode);
>struct fwnode_handle *fwnode_get_parent(const struct fwnode_handle *fwnode);
>struct fwnode_handle *fwnode_get_next_parent(
> struct fwnode_handle *fwnode);
>struct device *fwnode_get_next_parent_dev(struct fwnode_handle *fwnode);
>unsigned int fwnode_count_parents(const struct fwnode_handle *fwn);
>struct fwnode_handle *fwnode_get_nth_parent(struct fwnode_handle *fwn,
>         unsigned int depth);
>bool fwnode_is_ancestor_of(struct fwnode_handle *test_ancestor,
>      struct fwnode_handle *test_child);
>struct fwnode_handle *fwnode_get_next_child_node(
> const struct fwnode_handle *fwnode, struct fwnode_handle *child);
>struct fwnode_handle *fwnode_get_next_available_child_node(
> const struct fwnode_handle *fwnode, struct fwnode_handle *child);
># 108 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h"
>struct fwnode_handle *device_get_next_child_node(
> struct device *dev, struct fwnode_handle *child);
>
>
>
>
>
>struct fwnode_handle *fwnode_get_named_child_node(
> const struct fwnode_handle *fwnode, const char *childname);
>struct fwnode_handle *device_get_named_child_node(struct device *dev,
>        const char *childname);
>
>struct fwnode_handle *fwnode_handle_get(struct fwnode_handle *fwnode);
>void fwnode_handle_put(struct fwnode_handle *fwnode);
>
>int fwnode_irq_get(const struct fwnode_handle *fwnode, unsigned int index);
>int fwnode_irq_get_byname(const struct fwnode_handle *fwnode, const char *name);
>
>unsigned int device_get_child_node_count(struct device *dev);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool device_property_read_bool(struct device *dev,
>          const char *propname)
>{
> return device_property_present(dev, propname);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_read_u8(struct device *dev,
>       const char *propname, u8 *val)
>{
> return device_property_read_u8_array(dev, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_read_u16(struct device *dev,
>        const char *propname, u16 *val)
>{
> return device_property_read_u16_array(dev, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_read_u32(struct device *dev,
>        const char *propname, u32 *val)
>{
> return device_property_read_u32_array(dev, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_read_u64(struct device *dev,
>        const char *propname, u64 *val)
>{
> return device_property_read_u64_array(dev, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_count_u8(struct device *dev, const char *propname)
>{
> return device_property_read_u8_array(dev, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_count_u16(struct device *dev, const char *propname)
>{
> return device_property_read_u16_array(dev, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_count_u32(struct device *dev, const char *propname)
>{
> return device_property_read_u32_array(dev, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_count_u64(struct device *dev, const char *propname)
>{
> return device_property_read_u64_array(dev, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int device_property_string_array_count(struct device *dev,
>           const char *propname)
>{
> return device_property_read_string_array(dev, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fwnode_property_read_bool(const struct fwnode_handle *fwnode,
>          const char *propname)
>{
> return fwnode_property_present(fwnode, propname);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_read_u8(const struct fwnode_handle *fwnode,
>       const char *propname, u8 *val)
>{
> return fwnode_property_read_u8_array(fwnode, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_read_u16(const struct fwnode_handle *fwnode,
>        const char *propname, u16 *val)
>{
> return fwnode_property_read_u16_array(fwnode, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_read_u32(const struct fwnode_handle *fwnode,
>        const char *propname, u32 *val)
>{
> return fwnode_property_read_u32_array(fwnode, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_read_u64(const struct fwnode_handle *fwnode,
>        const char *propname, u64 *val)
>{
> return fwnode_property_read_u64_array(fwnode, propname, val, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_count_u8(const struct fwnode_handle *fwnode,
>        const char *propname)
>{
> return fwnode_property_read_u8_array(fwnode, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_count_u16(const struct fwnode_handle *fwnode,
>         const char *propname)
>{
> return fwnode_property_read_u16_array(fwnode, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_count_u32(const struct fwnode_handle *fwnode,
>         const char *propname)
>{
> return fwnode_property_read_u32_array(fwnode, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int fwnode_property_count_u64(const struct fwnode_handle *fwnode,
>         const char *propname)
>{
> return fwnode_property_read_u64_array(fwnode, propname, ((void *)0), 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>fwnode_property_string_array_count(const struct fwnode_handle *fwnode,
>       const char *propname)
>{
> return fwnode_property_read_string_array(fwnode, propname, ((void *)0), 0);
>}
>
>struct software_node;
>
>
>
>
>
>
>
>struct software_node_ref_args {
> const struct software_node *node;
> unsigned int nargs;
> u64 args[8];
>};
># 275 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h"
>struct property_entry {
> const char *name;
> size_t length;
> bool is_inline;
> enum dev_prop_type type;
> union {
>  const void *pointer;
>  union {
>   u8 u8_data[sizeof(u64) / sizeof(u8)];
>   u16 u16_data[sizeof(u64) / sizeof(u16)];
>   u32 u32_data[sizeof(u64) / sizeof(u32)];
>   u64 u64_data[sizeof(u64) / sizeof(u64)];
>   const char *str[sizeof(u64) / sizeof(char *)];
>  } value;
> };
>};
># 377 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h"
>struct property_entry *
>property_entries_dup(const struct property_entry *properties);
>
>void property_entries_free(const struct property_entry *properties);
>
>int device_add_properties(struct device *dev,
>     const struct property_entry *properties);
>void device_remove_properties(struct device *dev);
>
>bool device_dma_supported(struct device *dev);
>
>enum dev_dma_attr device_get_dma_attr(struct device *dev);
>
>const void *device_get_match_data(struct device *dev);
>
>int device_get_phy_mode(struct device *dev);
>
>int fwnode_get_phy_mode(struct fwnode_handle *fwnode);
>struct fwnode_handle *fwnode_graph_get_next_endpoint(
> const struct fwnode_handle *fwnode, struct fwnode_handle *prev);
>struct fwnode_handle *
>fwnode_graph_get_port_parent(const struct fwnode_handle *fwnode);
>struct fwnode_handle *fwnode_graph_get_remote_port_parent(
> const struct fwnode_handle *fwnode);
>struct fwnode_handle *fwnode_graph_get_remote_port(
> const struct fwnode_handle *fwnode);
>struct fwnode_handle *fwnode_graph_get_remote_endpoint(
> const struct fwnode_handle *fwnode);
>struct fwnode_handle *
>fwnode_graph_get_remote_node(const struct fwnode_handle *fwnode, u32 port,
>        u32 endpoint);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fwnode_graph_is_endpoint(struct fwnode_handle *fwnode)
>{
> return fwnode_property_present(fwnode, "remote-endpoint");
>}
># 428 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h"
>struct fwnode_handle *
>fwnode_graph_get_endpoint_by_id(const struct fwnode_handle *fwnode,
>    u32 port, u32 endpoint, unsigned long flags);
>
>
>
>
>
>int fwnode_graph_parse_endpoint(const struct fwnode_handle *fwnode,
>    struct fwnode_endpoint *endpoint);
>
>typedef void *(*devcon_match_fn_t)(struct fwnode_handle *fwnode, const char *id,
>       void *data);
>
>void *fwnode_connection_find_match(struct fwnode_handle *fwnode,
>       const char *con_id, void *data,
>       devcon_match_fn_t match);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *device_connection_find_match(struct device *dev,
>       const char *con_id, void *data,
>       devcon_match_fn_t match)
>{
> return fwnode_connection_find_match(dev_fwnode(dev), con_id, data, match);
>}
># 462 "/usr/src/linux-5.14.21-150500.53/include/linux/property.h"
>struct software_node {
> const char *name;
> const struct software_node *parent;
> const struct property_entry *properties;
>};
>
>bool is_software_node(const struct fwnode_handle *fwnode);
>const struct software_node *
>to_software_node(const struct fwnode_handle *fwnode);
>struct fwnode_handle *software_node_fwnode(const struct software_node *node);
>
>const struct software_node *
>software_node_find_by_name(const struct software_node *parent,
>      const char *name);
>
>int software_node_register_nodes(const struct software_node *nodes);
>void software_node_unregister_nodes(const struct software_node *nodes);
>
>int software_node_register_node_group(const struct software_node **node_group);
>void software_node_unregister_node_group(const struct software_node **node_group);
>
>int software_node_register(const struct software_node *node);
>void software_node_unregister(const struct software_node *node);
>
>int software_node_notify(struct device *dev, unsigned long action);
>
>struct fwnode_handle *
>fwnode_create_software_node(const struct property_entry *properties,
>       const struct fwnode_handle *parent);
>void fwnode_remove_software_node(struct fwnode_handle *fwnode);
>
>int device_add_software_node(struct device *dev, const struct software_node *node);
>void device_remove_software_node(struct device *dev);
>
>int device_create_managed_software_node(struct device *dev,
>     const struct property_entry *properties,
>     const struct software_node *parent);
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h" 2
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 1
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h" 2
>
>typedef u32 phandle;
>typedef u32 ihandle;
>
>struct property {
> char *name;
> int length;
> void *value;
> struct property *next;
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>};
>
>
>
>
>
>struct device_node {
> const char *name;
> phandle phandle;
> const char *full_name;
> struct fwnode_handle fwnode;
>
> struct property *properties;
> struct property *deadprops;
> struct device_node *parent;
> struct device_node *child;
> struct device_node *sibling;
>
>
>
> unsigned long _flags;
> void *data;
>
>
>
>
>};
>
>
>struct of_phandle_args {
> struct device_node *np;
> int args_count;
> uint32_t args[16];
>};
>
>struct of_phandle_iterator {
>
> const char *cells_name;
> int cell_count;
> const struct device_node *parent;
>
>
> const __be32 *list_end;
> const __be32 *phandle_end;
>
>
> const __be32 *cur;
> uint32_t cur_count;
> phandle phandle;
> struct device_node *node;
>};
>
>struct of_reconfig_data {
> struct device_node *dn;
> struct property *prop;
> struct property *old_prop;
>};
>
>
>extern struct kobj_type of_node_ktype;
>extern const struct fwnode_operations of_fwnode_ops;
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_node_init(struct device_node *node)
>{
>
>
>
> fwnode_init(&node->fwnode, &of_fwnode_ops);
>}
># 125 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_node_get(struct device_node *node)
>{
> return node;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_node_put(struct device_node *node) { }
>
>
>
>extern struct device_node *of_root;
>extern struct device_node *of_chosen;
>extern struct device_node *of_aliases;
>extern struct device_node *of_stdout;
>extern raw_spinlock_t devtree_lock;
># 580 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_core_init(void)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_of_node(const struct fwnode_handle *fwnode)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *to_of_node(const struct fwnode_handle *fwnode)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_node_name_eq(const struct device_node *np, const char *name)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_node_name_prefix(const struct device_node *np, const char *prefix)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char* of_node_full_name(const struct device_node *np)
>{
> return "<no-node>";
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_node_by_name(struct device_node *from,
> const char *name)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_node_by_type(struct device_node *from,
> const char *type)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_matching_node_and_match(
> struct device_node *from,
> const struct of_device_id *matches,
> const struct of_device_id **match)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_node_by_path(const char *path)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_node_opts_by_path(const char *path,
> const char **opts)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_node_by_phandle(phandle handle)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_parent(const struct device_node *node)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_next_parent(struct device_node *node)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_next_child(
> const struct device_node *node, struct device_node *prev)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_next_available_child(
> const struct device_node *node, struct device_node *prev)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_node_with_property(
> struct device_node *from, const char *prop_name)
>{
> return ((void *)0);
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_have_populated_dt(void)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_compatible_child(const struct device_node *parent,
>     const char *compatible)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_child_by_name(
>     const struct device_node *node,
>     const char *name)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_device_is_compatible(const struct device_node *device,
>       const char *name)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_device_compatible_match(struct device_node *device,
>           const char *const *compat)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_device_is_available(const struct device_node *device)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_device_is_big_endian(const struct device_node *device)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct property *of_find_property(const struct device_node *np,
>      const char *name,
>      int *lenp)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_compatible_node(
>      struct device_node *from,
>      const char *type,
>      const char *compat)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_count_elems_of_size(const struct device_node *np,
>   const char *propname, int elem_size)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u8_array(const struct device_node *np,
>   const char *propname, u8 *out_values, size_t sz)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u16_array(const struct device_node *np,
>   const char *propname, u16 *out_values, size_t sz)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u32_array(const struct device_node *np,
>          const char *propname,
>          u32 *out_values, size_t sz)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u64_array(const struct device_node *np,
>          const char *propname,
>          u64 *out_values, size_t sz)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u32_index(const struct device_node *np,
>   const char *propname, u32 index, u32 *out_value)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u64_index(const struct device_node *np,
>   const char *propname, u32 index, u64 *out_value)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const void *of_get_property(const struct device_node *node,
>    const char *name,
>    int *lenp)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_cpu_node(int cpu,
>     unsigned int *thread)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_next_cpu_node(struct device_node *prev)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_get_cpu_state_node(struct device_node *cpu_node,
>     int index)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_n_addr_cells(struct device_node *np)
>{
> return 0;
>
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_n_size_cells(struct device_node *np)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_variable_u8_array(const struct device_node *np,
>     const char *propname, u8 *out_values,
>     size_t sz_min, size_t sz_max)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_variable_u16_array(const struct device_node *np,
>     const char *propname, u16 *out_values,
>     size_t sz_min, size_t sz_max)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_variable_u32_array(const struct device_node *np,
>     const char *propname,
>     u32 *out_values,
>     size_t sz_min,
>     size_t sz_max)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u64(const struct device_node *np,
>           const char *propname, u64 *out_value)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_variable_u64_array(const struct device_node *np,
>     const char *propname,
>     u64 *out_values,
>     size_t sz_min,
>     size_t sz_max)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_string(const struct device_node *np,
>       const char *propname,
>       const char **out_string)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_match_string(const struct device_node *np,
>        const char *propname,
>        const char *string)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_string_helper(const struct device_node *np,
>       const char *propname,
>       const char **out_strs, size_t sz, int index)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_parse_phandle(const struct device_node *np,
>         const char *phandle_name,
>         int index)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_parse_phandle_with_args(const struct device_node *np,
>          const char *list_name,
>          const char *cells_name,
>          int index,
>          struct of_phandle_args *out_args)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_parse_phandle_with_args_map(const struct device_node *np,
>       const char *list_name,
>       const char *stem_name,
>       int index,
>       struct of_phandle_args *out_args)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_parse_phandle_with_fixed_args(const struct device_node *np,
> const char *list_name, int cells_count, int index,
> struct of_phandle_args *out_args)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_count_phandle_with_args(struct device_node *np,
>          const char *list_name,
>          const char *cells_name)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_phandle_iterator_init(struct of_phandle_iterator *it,
>        const struct device_node *np,
>        const char *list_name,
>        const char *cells_name,
>        int cell_count)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_phandle_iterator_next(struct of_phandle_iterator *it)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_phandle_iterator_args(struct of_phandle_iterator *it,
>        uint32_t *args,
>        int size)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_alias_get_id(struct device_node *np, const char *stem)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_alias_get_highest_id(const char *stem)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_alias_get_alias_list(const struct of_device_id *matches,
>       const char *stem, unsigned long *bitmap,
>       unsigned int nbits)
>{
> return -38;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_machine_is_compatible(const char *compat)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_remove_property(struct device_node *np, struct property *prop)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_console_check(const struct device_node *dn, const char *name, int index)
>{
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const __be32 *of_prop_next_u32(struct property *prop,
>  const __be32 *cur, u32 *pu)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *of_prop_next_string(struct property *prop,
>  const char *cur)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_node_check_flag(struct device_node *n, unsigned long flag)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_node_test_and_set_flag(struct device_node *n,
>         unsigned long flag)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_node_set_flag(struct device_node *n, unsigned long flag)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_node_clear_flag(struct device_node *n, unsigned long flag)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_check_flag(struct property *p, unsigned long flag)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_property_set_flag(struct property *p, unsigned long flag)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void of_property_clear_flag(struct property *p, unsigned long flag)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_cpu_node_to_id(struct device_node *np)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_map_id(struct device_node *np, u32 id,
>        const char *map_name, const char *map_mask_name,
>        struct device_node **target, u32 *id_out)
>{
> return -22;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) phys_addr_t of_dma_get_max_cpu_address(struct device_node *np)
>{
> return (~(phys_addr_t)0);
>}
># 1031 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_prop_val_eq(struct property *p1, struct property *p2)
>{
> return p1->length == p2->length &&
>        !memcmp(p1->value, p2->value, (size_t)p1->length);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_node_to_nid(struct device_node *device)
>{
> return (-1);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_numa_init(void)
>{
> return -38;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *of_find_matching_node(
> struct device_node *from,
> const struct of_device_id *matches)
>{
> return of_find_matching_node_and_match(from, matches, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *of_node_get_device_type(const struct device_node *np)
>{
> return of_get_property(np, "device_type", ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_node_is_type(const struct device_node *np, const char *type)
>{
> const char *match = of_node_get_device_type(np);
>
> return np && match && type && !strcmp(match, type);
>}
># 1087 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_count_u8_elems(const struct device_node *np,
>    const char *propname)
>{
> return of_property_count_elems_of_size(np, propname, sizeof(u8));
>}
># 1106 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_count_u16_elems(const struct device_node *np,
>    const char *propname)
>{
> return of_property_count_elems_of_size(np, propname, sizeof(u16));
>}
># 1125 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_count_u32_elems(const struct device_node *np,
>    const char *propname)
>{
> return of_property_count_elems_of_size(np, propname, sizeof(u32));
>}
># 1144 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_count_u64_elems(const struct device_node *np,
>    const char *propname)
>{
> return of_property_count_elems_of_size(np, propname, sizeof(u64));
>}
># 1163 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_string_array(const struct device_node *np,
>      const char *propname, const char **out_strs,
>      size_t sz)
>{
> return of_property_read_string_helper(np, propname, out_strs, sz, 0);
>}
># 1183 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_count_strings(const struct device_node *np,
>         const char *propname)
>{
> return of_property_read_string_helper(np, propname, ((void *)0), 0, 0);
>}
># 1208 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_string_index(const struct device_node *np,
>      const char *propname,
>      int index, const char **output)
>{
> int rc = of_property_read_string_helper(np, propname, output, 1, index);
> return rc < 0 ? rc : 0;
>}
># 1225 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_property_read_bool(const struct device_node *np,
>      const char *propname)
>{
> struct property *prop = of_find_property(np, propname, ((void *)0));
>
> return prop ? true : false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u8(const struct device_node *np,
>           const char *propname,
>           u8 *out_value)
>{
> return of_property_read_u8_array(np, propname, out_value, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u16(const struct device_node *np,
>           const char *propname,
>           u16 *out_value)
>{
> return of_property_read_u16_array(np, propname, out_value, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_u32(const struct device_node *np,
>           const char *propname,
>           u32 *out_value)
>{
> return of_property_read_u32_array(np, propname, out_value, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_property_read_s32(const struct device_node *np,
>           const char *propname,
>           s32 *out_value)
>{
> return of_property_read_u32(np, propname, (u32*) out_value);
>}
># 1310 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_get_child_count(const struct device_node *np)
>{
> struct device_node *child;
> int num = 0;
>
> for (child = of_get_next_child(np, ((void *)0)); child != ((void *)0); child = of_get_next_child(np, child))
>  num++;
>
> return num;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_get_available_child_count(const struct device_node *np)
>{
> struct device_node *child;
> int num = 0;
>
> for (child = of_get_next_available_child(np, ((void *)0)); child != ((void *)0); child = of_get_next_available_child(np, child))
>  num++;
>
> return num;
>}
># 1350 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>typedef int (*of_init_fn_2)(struct device_node *, struct device_node *);
>typedef int (*of_init_fn_1_ret)(struct device_node *);
>typedef void (*of_init_fn_1)(struct device_node *);
># 1375 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>struct of_changeset_entry {
> struct list_head node;
> unsigned long action;
> struct device_node *np;
> struct property *prop;
> struct property *old_prop;
>};
># 1393 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>struct of_changeset {
> struct list_head entries;
>};
>
>enum of_reconfig_change {
> OF_RECONFIG_NO_CHANGE = 0,
> OF_RECONFIG_CHANGE_ADD,
> OF_RECONFIG_CHANGE_REMOVE,
>};
># 1448 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_reconfig_notifier_register(struct notifier_block *nb)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_reconfig_notifier_unregister(struct notifier_block *nb)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_reconfig_notify(unsigned long action,
>         struct of_reconfig_data *arg)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_reconfig_get_state_change(unsigned long action,
>      struct of_reconfig_data *arg)
>{
> return -22;
>}
># 1474 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool of_device_is_system_power_controller(const struct device_node *np)
>{
> return of_property_read_bool(np, "system-power-controller");
>}
>
>
>
>
>
>enum of_overlay_notify_action {
> OF_OVERLAY_PRE_APPLY = 0,
> OF_OVERLAY_POST_APPLY,
> OF_OVERLAY_PRE_REMOVE,
> OF_OVERLAY_POST_REMOVE,
>};
>
>struct of_overlay_notify_data {
> struct device_node *overlay;
> struct device_node *target;
>};
># 1507 "/usr/src/linux-5.14.21-150500.53/include/linux/of.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_overlay_fdt_apply(void *overlay_fdt, u32 overlay_fdt_size,
>           int *ovcs_id)
>{
> return -524;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_overlay_remove(int *ovcs_id)
>{
> return -524;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_overlay_remove_all(void)
>{
> return -524;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_overlay_notifier_register(struct notifier_block *nb)
>{
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_overlay_notifier_unregister(struct notifier_block *nb)
>{
> return 0;
>}
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h" 2
>
>
>
>struct device_node;
>struct fwnode_handle;
>struct irq_domain;
>struct irq_chip;
>struct irq_data;
>struct irq_desc;
>struct cpumask;
>struct seq_file;
>struct irq_affinity_desc;
># 61 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
>struct irq_fwspec {
> struct fwnode_handle *fwnode;
> int param_count;
> u32 param[16];
>};
># 74 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
>enum irq_domain_bus_token {
> DOMAIN_BUS_ANY = 0,
> DOMAIN_BUS_WIRED,
> DOMAIN_BUS_GENERIC_MSI,
> DOMAIN_BUS_PCI_MSI,
> DOMAIN_BUS_PLATFORM_MSI,
> DOMAIN_BUS_NEXUS,
> DOMAIN_BUS_IPI,
> DOMAIN_BUS_FSL_MC_MSI,
> DOMAIN_BUS_TI_SCI_INTA_MSI,
> DOMAIN_BUS_WAKEUP,
> DOMAIN_BUS_VMD_MSI,
>};
># 103 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
>struct irq_domain_ops {
> int (*match)(struct irq_domain *d, struct device_node *node,
>       enum irq_domain_bus_token bus_token);
> int (*select)(struct irq_domain *d, struct irq_fwspec *fwspec,
>        enum irq_domain_bus_token bus_token);
> int (*map)(struct irq_domain *d, unsigned int virq, irq_hw_number_t hw);
> void (*unmap)(struct irq_domain *d, unsigned int virq);
> int (*xlate)(struct irq_domain *d, struct device_node *node,
>       const u32 *intspec, unsigned int intsize,
>       unsigned long *out_hwirq, unsigned int *out_type);
>
>
> int (*alloc)(struct irq_domain *d, unsigned int virq,
>       unsigned int nr_irqs, void *arg);
> void (*free)(struct irq_domain *d, unsigned int virq,
>       unsigned int nr_irqs);
> int (*activate)(struct irq_domain *d, struct irq_data *irqd, bool reserve);
> void (*deactivate)(struct irq_domain *d, struct irq_data *irq_data);
> int (*translate)(struct irq_domain *d, struct irq_fwspec *fwspec,
>    unsigned long *out_hwirq, unsigned int *out_type);
>
>
> void (*debug_show)(struct seq_file *m, struct irq_domain *d,
>      struct irq_data *irqd, int ind);
>
>};
>
>extern struct irq_domain_ops irq_generic_chip_ops;
>
>struct irq_domain_chip_generic;
># 158 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
>struct irq_domain {
> struct list_head link;
> const char *name;
> const struct irq_domain_ops *ops;
> void *host_data;
> unsigned int flags;
> unsigned int mapcount;
>
>
> struct 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_size;
> struct xarray revmap_tree;
> struct mutex revmap_mutex;
> struct irq_data *revmap[];
>};
>
>
>enum {
>
> IRQ_DOMAIN_FLAG_HIERARCHY = (1 << 0),
>
>
> IRQ_DOMAIN_NAME_ALLOCATED = (1 << 1),
>
>
> IRQ_DOMAIN_FLAG_IPI_PER_CPU = (1 << 2),
>
>
> IRQ_DOMAIN_FLAG_IPI_SINGLE = (1 << 3),
>
>
> IRQ_DOMAIN_FLAG_MSI = (1 << 4),
>
>
> IRQ_DOMAIN_FLAG_MSI_REMAP = (1 << 5),
>
>
>
>
>
>
> IRQ_DOMAIN_MSI_NOMASK_QUIRK = (1 << 6),
>
>
> IRQ_DOMAIN_FLAG_NO_MAP = (1 << 7),
>
>
>
>
>
>
> IRQ_DOMAIN_FLAG_NONCORE = (1 << 16),
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct device_node *irq_domain_get_of_node(struct irq_domain *d)
>{
> return to_of_node(d->fwnode);
>}
>
>
>struct fwnode_handle *__irq_domain_alloc_fwnode(unsigned int type, int id,
>      const char *name, phys_addr_t *pa);
>
>enum {
> IRQCHIP_FWNODE_REAL,
> IRQCHIP_FWNODE_NAMED,
> IRQCHIP_FWNODE_NAMED_ID,
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct fwnode_handle *irq_domain_alloc_named_fwnode(const char *name)
>{
> return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_NAMED, 0, name, ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct fwnode_handle *irq_domain_alloc_named_id_fwnode(const char *name, int id)
>{
> return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_NAMED_ID, id, name,
>      ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fwnode_handle *irq_domain_alloc_fwnode(phys_addr_t *pa)
>{
> return __irq_domain_alloc_fwnode(IRQCHIP_FWNODE_REAL, 0, ((void *)0), pa);
>}
>
>void irq_domain_free_fwnode(struct fwnode_handle *fwnode);
>struct irq_domain *__irq_domain_add(struct fwnode_handle *fwnode, int size,
>        irq_hw_number_t hwirq_max, int direct_max,
>        const struct irq_domain_ops *ops,
>        void *host_data);
>struct irq_domain *irq_domain_create_simple(struct fwnode_handle *fwnode,
>         unsigned int size,
>         unsigned int first_irq,
>         const struct irq_domain_ops *ops,
>         void *host_data);
>struct irq_domain *irq_domain_add_legacy(struct device_node *of_node,
>      unsigned int size,
>      unsigned int first_irq,
>      irq_hw_number_t first_hwirq,
>      const struct irq_domain_ops *ops,
>      void *host_data);
>struct irq_domain *irq_domain_create_legacy(struct fwnode_handle *fwnode,
>         unsigned int size,
>         unsigned int first_irq,
>         irq_hw_number_t first_hwirq,
>         const struct irq_domain_ops *ops,
>         void *host_data);
>extern struct irq_domain *irq_find_matching_fwspec(struct irq_fwspec *fwspec,
>         enum irq_domain_bus_token bus_token);
>extern bool irq_domain_check_msi_remap(void);
>extern void irq_set_default_host(struct irq_domain *host);
>extern struct irq_domain *irq_get_default_host(void);
>extern int irq_domain_alloc_descs(int virq, unsigned int nr_irqs,
>      irq_hw_number_t hwirq, int node,
>      const struct irq_affinity_desc *affinity);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fwnode_handle *of_node_to_fwnode(struct device_node *node)
>{
> return node ? &node->fwnode : ((void *)0);
>}
>
>extern const struct fwnode_operations irqchip_fwnode_ops;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_fwnode_irqchip(struct fwnode_handle *fwnode)
>{
> return fwnode && fwnode->ops == &irqchip_fwnode_ops;
>}
>
>extern void irq_domain_update_bus_token(struct irq_domain *domain,
>     enum irq_domain_bus_token bus_token);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct irq_domain *irq_find_matching_fwnode(struct fwnode_handle *fwnode,
>         enum irq_domain_bus_token bus_token)
>{
> struct irq_fwspec fwspec = {
>  .fwnode = fwnode,
> };
>
> return irq_find_matching_fwspec(&fwspec, bus_token);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_find_matching_host(struct device_node *node,
>       enum irq_domain_bus_token bus_token)
>{
> return irq_find_matching_fwnode(of_node_to_fwnode(node), bus_token);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_find_host(struct device_node *node)
>{
> struct irq_domain *d;
>
> d = irq_find_matching_host(node, DOMAIN_BUS_WIRED);
> if (!d)
>  d = irq_find_matching_host(node, DOMAIN_BUS_ANY);
>
> return d;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_domain_add_simple(struct device_node *of_node,
>             unsigned int size,
>             unsigned int first_irq,
>             const struct irq_domain_ops *ops,
>             void *host_data)
>{
> return irq_domain_create_simple(of_node_to_fwnode(of_node), size, first_irq, ops, host_data);
>}
># 343 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_domain_add_linear(struct device_node *of_node,
>      unsigned int size,
>      const struct irq_domain_ops *ops,
>      void *host_data)
>{
> return __irq_domain_add(of_node_to_fwnode(of_node), size, size, 0, ops, host_data);
>}
># 363 "/usr/src/linux-5.14.21-150500.53/include/linux/irqdomain.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_domain_add_tree(struct device_node *of_node,
>      const struct irq_domain_ops *ops,
>      void *host_data)
>{
> return __irq_domain_add(of_node_to_fwnode(of_node), 0, ~0, 0, ops, host_data);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_domain_create_linear(struct fwnode_handle *fwnode,
>      unsigned int size,
>      const struct irq_domain_ops *ops,
>      void *host_data)
>{
> return __irq_domain_add(fwnode, size, size, 0, ops, host_data);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_domain_create_tree(struct fwnode_handle *fwnode,
>      const struct irq_domain_ops *ops,
>      void *host_data)
>{
> return __irq_domain_add(fwnode, 0, ~0, 0, ops, host_data);
>}
>
>extern void irq_domain_remove(struct irq_domain *host);
>
>extern int irq_domain_associate(struct irq_domain *domain, unsigned int irq,
>     irq_hw_number_t hwirq);
>extern void irq_domain_associate_many(struct irq_domain *domain,
>          unsigned int irq_base,
>          irq_hw_number_t hwirq_base, int count);
>
>extern unsigned int irq_create_mapping_affinity(struct irq_domain *host,
>          irq_hw_number_t hwirq,
>          const struct irq_affinity_desc *affinity);
>extern unsigned int irq_create_fwspec_mapping(struct irq_fwspec *fwspec);
>extern void irq_dispose_mapping(unsigned int virq);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int irq_create_mapping(struct irq_domain *host,
>           irq_hw_number_t hwirq)
>{
> return irq_create_mapping_affinity(host, hwirq, ((void *)0));
>}
>
>extern struct irq_desc *__irq_resolve_mapping(struct irq_domain *domain,
>           irq_hw_number_t hwirq,
>           unsigned int *irq);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_desc *irq_resolve_mapping(struct irq_domain *domain,
>         irq_hw_number_t hwirq)
>{
> return __irq_resolve_mapping(domain, hwirq, ((void *)0));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int irq_find_mapping(struct irq_domain *domain,
>         irq_hw_number_t hwirq)
>{
> unsigned int irq;
>
> if (__irq_resolve_mapping(domain, hwirq, &irq))
>  return irq;
>
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int irq_linear_revmap(struct irq_domain *domain,
>          irq_hw_number_t hwirq)
>{
> return irq_find_mapping(domain, hwirq);
>}
>
>extern const struct irq_domain_ops irq_domain_simple_ops;
>
>
>int irq_domain_xlate_onecell(struct irq_domain *d, struct device_node *ctrlr,
>   const u32 *intspec, unsigned int intsize,
>   irq_hw_number_t *out_hwirq, unsigned int *out_type);
>int irq_domain_xlate_twocell(struct irq_domain *d, struct device_node *ctrlr,
>   const u32 *intspec, unsigned int intsize,
>   irq_hw_number_t *out_hwirq, unsigned int *out_type);
>int irq_domain_xlate_onetwocell(struct irq_domain *d, struct device_node *ctrlr,
>   const u32 *intspec, unsigned int intsize,
>   irq_hw_number_t *out_hwirq, unsigned int *out_type);
>
>int irq_domain_translate_twocell(struct irq_domain *d,
>     struct irq_fwspec *fwspec,
>     unsigned long *out_hwirq,
>     unsigned int *out_type);
>
>int irq_domain_translate_onecell(struct irq_domain *d,
>     struct irq_fwspec *fwspec,
>     unsigned long *out_hwirq,
>     unsigned int *out_type);
>
>
>int irq_reserve_ipi(struct irq_domain *domain, const struct cpumask *dest);
>int irq_destroy_ipi(unsigned int irq, const struct cpumask *dest);
>
>
>extern struct irq_data *irq_domain_get_irq_data(struct irq_domain *domain,
>      unsigned int virq);
>extern void irq_domain_set_info(struct irq_domain *domain, unsigned int virq,
>    irq_hw_number_t hwirq, struct irq_chip *chip,
>    void *chip_data, irq_flow_handler_t handler,
>    void *handler_data, const char *handler_name);
>extern void irq_domain_reset_irq_data(struct irq_data *irq_data);
>
>extern struct irq_domain *irq_domain_create_hierarchy(struct irq_domain *parent,
>   unsigned int flags, unsigned int size,
>   struct fwnode_handle *fwnode,
>   const struct irq_domain_ops *ops, void *host_data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct irq_domain *irq_domain_add_hierarchy(struct irq_domain *parent,
>         unsigned int flags,
>         unsigned int size,
>         struct device_node *node,
>         const struct irq_domain_ops *ops,
>         void *host_data)
>{
> return irq_domain_create_hierarchy(parent, flags, size,
>        of_node_to_fwnode(node),
>        ops, host_data);
>}
>
>extern int __irq_domain_alloc_irqs(struct irq_domain *domain, int irq_base,
>       unsigned int nr_irqs, int node, void *arg,
>       bool realloc,
>       const struct irq_affinity_desc *affinity);
>extern void irq_domain_free_irqs(unsigned int virq, unsigned int nr_irqs);
>extern int irq_domain_activate_irq(struct irq_data *irq_data, bool early);
>extern void irq_domain_deactivate_irq(struct irq_data *irq_data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int irq_domain_alloc_irqs(struct irq_domain *domain,
>   unsigned int nr_irqs, int node, void *arg)
>{
> return __irq_domain_alloc_irqs(domain, -1, nr_irqs, node, arg, false,
>           ((void *)0));
>}
>
>extern int irq_domain_alloc_irqs_hierarchy(struct irq_domain *domain,
>        unsigned int irq_base,
>        unsigned int nr_irqs, void *arg);
>extern int irq_domain_set_hwirq_and_chip(struct irq_domain *domain,
>      unsigned int virq,
>      irq_hw_number_t hwirq,
>      struct irq_chip *chip,
>      void *chip_data);
>extern void irq_domain_free_irqs_common(struct irq_domain *domain,
>     unsigned int virq,
>     unsigned int nr_irqs);
>extern void irq_domain_free_irqs_top(struct irq_domain *domain,
>         unsigned int virq, unsigned int nr_irqs);
>
>extern int irq_domain_push_irq(struct irq_domain *domain, int virq, void *arg);
>extern int irq_domain_pop_irq(struct irq_domain *domain, int virq);
>
>extern int irq_domain_alloc_irqs_parent(struct irq_domain *domain,
>     unsigned int irq_base,
>     unsigned int nr_irqs, void *arg);
>
>extern void irq_domain_free_irqs_parent(struct irq_domain *domain,
>     unsigned int irq_base,
>     unsigned int nr_irqs);
>
>extern int irq_domain_disconnect_hierarchy(struct irq_domain *domain,
>        unsigned int virq);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool irq_domain_is_hierarchy(struct irq_domain *domain)
>{
> return domain->flags & IRQ_DOMAIN_FLAG_HIERARCHY;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool irq_domain_is_ipi(struct irq_domain *domain)
>{
> return domain->flags &
>  (IRQ_DOMAIN_FLAG_IPI_PER_CPU | IRQ_DOMAIN_FLAG_IPI_SINGLE);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool irq_domain_is_ipi_per_cpu(struct irq_domain *domain)
>{
> return domain->flags & IRQ_DOMAIN_FLAG_IPI_PER_CPU;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool irq_domain_is_ipi_single(struct irq_domain *domain)
>{
> return domain->flags & IRQ_DOMAIN_FLAG_IPI_SINGLE;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool irq_domain_is_msi(struct irq_domain *domain)
>{
> return domain->flags & IRQ_DOMAIN_FLAG_MSI;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool irq_domain_is_msi_remap(struct irq_domain *domain)
>{
> return domain->flags & IRQ_DOMAIN_FLAG_MSI_REMAP;
>}
>
>extern bool irq_domain_hierarchical_is_msi_remap(struct irq_domain *domain);
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 2
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenv.h" 1
># 152 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenv.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acgcc.h" 1
># 153 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenv.h" 2
># 163 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenv.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/aclinux.h" 1
># 64 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/aclinux.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acenv.h" 1
># 30 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acenv.h"
>int __acpi_acquire_global_lock(unsigned int *lock);
>int __acpi_release_global_lock(unsigned int *lock);
># 65 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/aclinux.h" 2
># 164 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenv.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acnames.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h" 1
># 125 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef s64 acpi_native_int;
>
>typedef u64 acpi_size;
>typedef u64 acpi_io_address;
>typedef u64 acpi_physical_address;
># 421 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u32 acpi_status;
>typedef u32 acpi_name;
>typedef char *acpi_string;
>typedef void *acpi_handle;
># 445 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u16 acpi_owner_id;
># 472 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u64 acpi_integer;
># 644 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u32 acpi_object_type;
># 716 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u32 acpi_event_type;
># 747 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u32 acpi_event_status;
># 814 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef u8 acpi_adr_space_type;
># 908 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>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;
>};
># 978 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>struct acpi_buffer {
> acpi_size length;
> void *pointer;
>};
># 994 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>struct acpi_predefined_names {
> const char *name;
> u8 type;
> char *val;
>};
># 1011 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>struct acpi_system_info {
> u32 acpi_ca_version;
> u32 flags;
> u32 timer_resolution;
> u32 reserved1;
> u32 reserved2;
> u32 debug_level;
> u32 debug_layer;
>};
>
>
>
>
>struct acpi_statistics {
> u32 sci_count;
> u32 gpe_count;
> u32 fixed_event_count[4 + 1];
> u32 method_count;
>};
>
>
>
>
>typedef u32
> ( * acpi_osd_handler) (void *context);
>
>typedef void
> ( * acpi_osd_exec_callback) (void *context);
>
>
>
>
>typedef
>u32 (*acpi_sci_handler) (void *context);
>
>typedef
>void (*acpi_gbl_event_handler) (u32 event_type,
>          acpi_handle device,
>          u32 event_number, void *context);
>
>
>
>
>typedef
>u32(*acpi_event_handler) (void *context);
>
>typedef
>u32 (*acpi_gpe_handler) (acpi_handle gpe_device, u32 gpe_number, void *context);
>
>typedef
>void (*acpi_notify_handler) (acpi_handle device, u32 value, void *context);
>
>typedef
>void (*acpi_object_handler) (acpi_handle object, void *data);
>
>typedef
>acpi_status (*acpi_init_handler) (acpi_handle object, u32 function);
>
>
>
>typedef
>acpi_status (*acpi_exception_handler) (acpi_status aml_status,
>           acpi_name name,
>           u16 opcode,
>           u32 aml_offset, void *context);
>
>
>
>typedef
>acpi_status (*acpi_table_handler) (u32 event, void *table, void *context);
># 1092 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>typedef
>acpi_status (*acpi_adr_space_handler) (u32 function,
>           acpi_physical_address address,
>           u32 bit_width,
>           u64 *value,
>           void *handler_context,
>           void *region_context);
>
>
>
>
>
>struct acpi_connection_info {
> u8 *connection;
> u16 length;
> u8 access_length;
>};
>
>
>
>struct acpi_pcc_info {
> u8 subspace_id;
> u16 length;
> u8 *internal_buffer;
>};
>
>typedef
>acpi_status (*acpi_adr_space_setup) (acpi_handle region_handle,
>         u32 function,
>         void *handler_context,
>         void **region_context);
>
>
>
>
>typedef
>acpi_status (*acpi_walk_callback) (acpi_handle object,
>       u32 nesting_level,
>       void *context, void **return_value);
>
>typedef
>u32 (*acpi_interface_handler) (acpi_string interface_name, u32 supported);
># 1158 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>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[];
>};
>
>
>
>
>
>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];
> 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;
>};
># 1214 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>struct acpi_pci_id {
> u16 segment;
> u16 bus;
> u16 device;
> u16 function;
>};
>
>struct acpi_mem_mapping {
> acpi_physical_address physical_address;
> u8 *logical_address;
> acpi_size length;
> struct acpi_mem_mapping *next_mm;
>};
>
>struct acpi_mem_space_context {
> u32 length;
> acpi_physical_address address;
> struct acpi_mem_mapping *cur_mm;
> struct acpi_mem_mapping *first_mm;
>};
>
>struct acpi_data_table_space_context {
> void *pointer;
>};
>
>
>
>
>struct acpi_memory_list {
> const char *list_name;
> void *list_head;
> u16 object_size;
> u16 max_depth;
> u16 current_depth;
># 1261 "/usr/src/linux-5.14.21-150500.53/include/acpi/actypes.h"
>};
>
>
>
>typedef enum {
> ACPI_TRACE_AML_METHOD,
> ACPI_TRACE_AML_OPCODE,
> ACPI_TRACE_AML_REGION
>} acpi_trace_event_type;
># 25 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acexcep.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/include/acpi/acexcep.h"
>struct acpi_exception_info {
> char *name;
>
>
>
>
>};
># 26 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h" 1
># 47 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>#pragma pack(1)
># 68 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>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;
>};
># 90 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>struct acpi_generic_address {
> u8 space_id;
> u8 bit_width;
> u8 bit_offset;
> u8 access_width;
> u64 address;
>};
># 105 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>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];
>};
>
>
>
>struct acpi_rsdp_common {
> char signature[8];
> u8 checksum;
> char oem_id[6];
> u8 revision;
> u32 rsdt_physical_address;
>};
>
>
>
>struct acpi_rsdp_extension {
> u32 length;
> u64 xsdt_physical_address;
> u8 extended_checksum;
> u8 reserved[3];
>};
># 143 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>struct acpi_table_rsdt {
> struct acpi_table_header header;
> u32 table_offset_entry[1];
>};
>
>struct acpi_table_xsdt {
> struct acpi_table_header header;
> u64 table_offset_entry[1];
>};
># 162 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>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];
>};
># 199 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>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;
>};
># 301 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>enum acpi_preferred_pm_profiles {
> PM_UNSPECIFIED = 0,
> PM_DESKTOP = 1,
> PM_MOBILE = 2,
> PM_WORKSTATION = 3,
> PM_ENTERPRISE_SERVER = 4,
> PM_SOHO_SERVER = 5,
> PM_APPLIANCE_PC = 6,
> PM_PERFORMANCE_SERVER = 7,
> PM_TABLET = 8
>};
># 322 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
>#pragma pack()
>
>
>
>
>union acpi_name_union {
> u32 integer;
> char ascii[4];
>};
>
>
>
>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;
> u16 validation_count;
>};
># 370 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h" 1
># 70 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>#pragma pack(1)
># 92 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_subtable_header {
> u8 type;
> u8 length;
>};
>
>
>
>struct acpi_whea_header {
> u8 action;
> u8 instruction;
> u8 flags;
> u8 reserved;
> struct acpi_generic_address register_region;
> u64 value;
> u64 mask;
>};
># 118 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_asf {
> struct acpi_table_header header;
>};
>
>
>
>struct acpi_asf_header {
> u8 type;
> u8 reserved;
> u16 length;
>};
>
>
>
>enum acpi_asf_type {
> ACPI_ASF_TYPE_INFO = 0,
> ACPI_ASF_TYPE_ALERT = 1,
> ACPI_ASF_TYPE_CONTROL = 2,
> ACPI_ASF_TYPE_BOOT = 3,
> ACPI_ASF_TYPE_ADDRESS = 4,
> ACPI_ASF_TYPE_RESERVED = 5
>};
>
>
>
>
>
>
>
>struct acpi_asf_info {
> struct acpi_asf_header header;
> u8 min_reset_value;
> u8 min_poll_interval;
> u16 system_id;
> u32 mfg_id;
> u8 flags;
> u8 reserved2[3];
>};
>
>
>
>
>
>
>
>struct acpi_asf_alert {
> struct acpi_asf_header header;
> u8 assert_mask;
> u8 deassert_mask;
> u8 alerts;
> u8 data_length;
>};
>
>struct acpi_asf_alert_data {
> u8 address;
> u8 command;
> u8 mask;
> u8 value;
> u8 sensor_type;
> u8 type;
> u8 offset;
> u8 source_type;
> u8 severity;
> u8 sensor_number;
> u8 entity;
> u8 instance;
>};
>
>
>
>struct acpi_asf_remote {
> struct acpi_asf_header header;
> u8 controls;
> u8 data_length;
> u16 reserved2;
>};
>
>struct acpi_asf_control_data {
> u8 function;
> u8 address;
> u8 command;
> u8 value;
>};
>
>
>
>struct acpi_asf_rmcp {
> struct acpi_asf_header header;
> u8 capabilities[7];
> u8 completion_code;
> u32 enterprise_id;
> u8 command;
> u16 parameter;
> u16 boot_options;
> u16 oem_parameters;
>};
>
>
>
>struct acpi_asf_address {
> struct acpi_asf_header header;
> u8 eprom_address;
> u8 devices;
>};
># 230 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_bert {
> struct acpi_table_header header;
> u32 region_length;
> u64 address;
>};
>
>
>
>struct acpi_bert_region {
> u32 block_status;
> u32 raw_data_offset;
> u32 raw_data_length;
> u32 data_length;
> u32 error_severity;
>};
># 256 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>enum acpi_bert_error_severity {
> ACPI_BERT_ERROR_CORRECTABLE = 0,
> ACPI_BERT_ERROR_FATAL = 1,
> ACPI_BERT_ERROR_CORRECTED = 2,
> ACPI_BERT_ERROR_NONE = 3,
> ACPI_BERT_ERROR_RESERVED = 4
>};
># 276 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_bgrt {
> struct acpi_table_header header;
> u16 version;
> u8 status;
> u8 image_type;
> u64 image_address;
> u32 image_offset_x;
> u32 image_offset_y;
>};
># 300 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_boot {
> struct acpi_table_header header;
> u8 cmos_index;
> u8 reserved[3];
>};
># 315 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_cedt {
> struct acpi_table_header header;
>};
>
>
>
>struct acpi_cedt_header {
> u8 type;
> u8 reserved;
> u16 length;
>};
>
>
>
>enum acpi_cedt_type {
> ACPI_CEDT_TYPE_CHBS = 0,
> ACPI_CEDT_TYPE_CFMWS = 1,
> ACPI_CEDT_TYPE_RESERVED = 2,
>};
># 351 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_cedt_chbs {
> struct acpi_cedt_header header;
> u32 uid;
> u32 cxl_version;
> u32 reserved;
> u64 base;
> u64 length;
>};
>
>
>
>struct acpi_cedt_cfmws {
> struct acpi_cedt_header header;
> u32 reserved1;
> u64 base_hpa;
> u64 window_size;
> u8 interleave_ways;
> u8 interleave_arithmetic;
> u16 reserved2;
> u32 granularity;
> u16 restrictions;
> u16 qtg_id;
> u32 interleave_targets[];
>};
>
>struct acpi_cedt_cfmws_target_element {
> u32 interleave_target;
>};
># 399 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_cpep {
> struct acpi_table_header header;
> u64 reserved;
>};
>
>
>
>struct acpi_cpep_polling {
> struct acpi_subtable_header header;
> u8 id;
> u8 eid;
> u32 interval;
>};
># 422 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_csrt {
> struct acpi_table_header header;
>};
>
>
>
>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;
>
>
>};
>
>
>
>struct acpi_csrt_descriptor {
> u32 length;
> u16 type;
> u16 subtype;
> u32 uid;
>
>
>};
># 494 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_dbg2 {
> struct acpi_table_header header;
> u32 info_offset;
> u32 info_count;
>};
>
>struct acpi_dbg2_header {
> u32 info_offset;
> u32 info_count;
>};
>
>
>
>struct acpi_dbg2_device {
> u8 revision;
> u16 length;
> u8 register_count;
> u16 namepath_length;
> u16 namepath_offset;
> u16 oem_data_length;
> u16 oem_data_offset;
> u16 port_type;
> u16 port_subtype;
> u16 reserved;
> u16 base_address_offset;
> u16 address_size_offset;
>
>
>
>
>
>
>
>};
># 573 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_dbgp {
> struct acpi_table_header header;
> u8 type;
> u8 reserved[3];
> struct acpi_generic_address debug_port;
>};
># 590 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_dmar {
> struct acpi_table_header header;
> u8 width;
> u8 flags;
> u8 reserved[10];
>};
># 605 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_dmar_header {
> u16 type;
> u16 length;
>};
>
>
>
>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_SATC = 5,
> ACPI_DMAR_TYPE_RESERVED = 6
>};
>
>
>
>struct acpi_dmar_device_scope {
> u8 entry_type;
> u8 length;
> u16 reserved;
> u8 enumeration_id;
> u8 bus;
>};
>
>
>
>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
>};
>
>struct acpi_dmar_pci_path {
> u8 device;
> u8 function;
>};
>
>
>
>
>
>
>
>struct acpi_dmar_hardware_unit {
> struct acpi_dmar_header header;
> u8 flags;
> u8 reserved;
> u16 segment;
> u64 address;
>};
>
>
>
>
>
>
>
>struct acpi_dmar_reserved_memory {
> struct acpi_dmar_header header;
> u16 reserved;
> u16 segment;
> u64 base_address;
> u64 end_address;
>};
>
>
>
>
>
>
>
>struct acpi_dmar_atsr {
> struct acpi_dmar_header header;
> u8 flags;
> u8 reserved;
> u16 segment;
>};
>
>
>
>
>
>
>
>struct acpi_dmar_rhsa {
> struct acpi_dmar_header header;
> u32 reserved;
> u64 base_address;
> u32 proximity_domain;
>};
>
>
>
>struct acpi_dmar_andd {
> struct acpi_dmar_header header;
> u8 reserved[3];
> u8 device_number;
> char device_name[1];
>};
>
>
>
>struct acpi_dmar_satc {
> struct acpi_dmar_header header;
> u8 flags;
> u8 reserved;
> u16 segment;
>};
># 728 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_drtm {
> struct acpi_table_header header;
> u64 entry_base_address;
> u64 entry_length;
> u32 entry_address32;
> u64 entry_address64;
> u64 exit_address;
> u64 log_area_address;
> u32 log_area_length;
> u64 arch_dependent_address;
> u32 flags;
>};
># 750 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_drtm_vtable_list {
> u32 validated_table_count;
> u64 validated_tables[1];
>};
>
>
>
>
>
>struct acpi_drtm_resource {
> u8 size[7];
> u8 type;
> u64 address;
>};
>
>struct acpi_drtm_resource_list {
> u32 resource_count;
> struct acpi_drtm_resource resources[1];
>};
>
>
>
>struct acpi_drtm_dps_id {
> u32 dps_id_length;
> u8 dps_id[16];
>};
># 784 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>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];
>};
># 800 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_einj {
> struct acpi_table_header header;
> u32 header_length;
> u8 flags;
> u8 reserved[3];
> u32 entries;
>};
>
>
>
>struct acpi_einj_entry {
> struct acpi_whea_header whea_header;
>};
>
>
>
>
>
>
>
>enum acpi_einj_actions {
> ACPI_EINJ_BEGIN_OPERATION = 0,
> ACPI_EINJ_GET_TRIGGER_TABLE = 1,
> ACPI_EINJ_SET_ERROR_TYPE = 2,
> ACPI_EINJ_GET_ERROR_TYPE = 3,
> ACPI_EINJ_END_OPERATION = 4,
> ACPI_EINJ_EXECUTE_OPERATION = 5,
> ACPI_EINJ_CHECK_BUSY_STATUS = 6,
> ACPI_EINJ_GET_COMMAND_STATUS = 7,
> ACPI_EINJ_SET_ERROR_TYPE_WITH_ADDRESS = 8,
> ACPI_EINJ_GET_EXECUTE_TIMINGS = 9,
> ACPI_EINJ_ACTION_RESERVED = 10,
> ACPI_EINJ_TRIGGER_ERROR = 0xFF
>};
>
>
>
>enum acpi_einj_instructions {
> ACPI_EINJ_READ_REGISTER = 0,
> ACPI_EINJ_READ_REGISTER_VALUE = 1,
> ACPI_EINJ_WRITE_REGISTER = 2,
> ACPI_EINJ_WRITE_REGISTER_VALUE = 3,
> ACPI_EINJ_NOOP = 4,
> ACPI_EINJ_FLUSH_CACHELINE = 5,
> ACPI_EINJ_INSTRUCTION_RESERVED = 6
>};
>
>struct acpi_einj_error_type_with_addr {
> u32 error_type;
> u32 vendor_struct_offset;
> u32 flags;
> u32 apic_id;
> u64 address;
> u64 range;
> u32 pcie_id;
>};
>
>struct acpi_einj_vendor {
> u32 length;
> u32 pcie_id;
> u16 vendor_id;
> u16 device_id;
> u8 revision_id;
> u8 reserved[3];
>};
>
>
>
>struct acpi_einj_trigger {
> u32 header_size;
> u32 revision;
> u32 table_size;
> u32 entry_count;
>};
>
>
>
>enum acpi_einj_command_status {
> ACPI_EINJ_SUCCESS = 0,
> ACPI_EINJ_FAILURE = 1,
> ACPI_EINJ_INVALID_ACCESS = 2,
> ACPI_EINJ_STATUS_RESERVED = 3
>};
># 907 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_erst {
> struct acpi_table_header header;
> u32 header_length;
> u32 reserved;
> u32 entries;
>};
>
>
>
>struct acpi_erst_entry {
> struct acpi_whea_header whea_header;
>};
>
>
>
>
>
>
>
>enum acpi_erst_actions {
> ACPI_ERST_BEGIN_WRITE = 0,
> ACPI_ERST_BEGIN_READ = 1,
> ACPI_ERST_BEGIN_CLEAR = 2,
> ACPI_ERST_END = 3,
> ACPI_ERST_SET_RECORD_OFFSET = 4,
> ACPI_ERST_EXECUTE_OPERATION = 5,
> ACPI_ERST_CHECK_BUSY_STATUS = 6,
> ACPI_ERST_GET_COMMAND_STATUS = 7,
> ACPI_ERST_GET_RECORD_ID = 8,
> ACPI_ERST_SET_RECORD_ID = 9,
> ACPI_ERST_GET_RECORD_COUNT = 10,
> ACPI_ERST_BEGIN_DUMMY_WRIITE = 11,
> ACPI_ERST_NOT_USED = 12,
> ACPI_ERST_GET_ERROR_RANGE = 13,
> ACPI_ERST_GET_ERROR_LENGTH = 14,
> ACPI_ERST_GET_ERROR_ATTRIBUTES = 15,
> ACPI_ERST_EXECUTE_TIMINGS = 16,
> ACPI_ERST_ACTION_RESERVED = 17
>};
>
>
>
>enum acpi_erst_instructions {
> ACPI_ERST_READ_REGISTER = 0,
> ACPI_ERST_READ_REGISTER_VALUE = 1,
> ACPI_ERST_WRITE_REGISTER = 2,
> ACPI_ERST_WRITE_REGISTER_VALUE = 3,
> ACPI_ERST_NOOP = 4,
> ACPI_ERST_LOAD_VAR1 = 5,
> ACPI_ERST_LOAD_VAR2 = 6,
> ACPI_ERST_STORE_VAR1 = 7,
> ACPI_ERST_ADD = 8,
> ACPI_ERST_SUBTRACT = 9,
> ACPI_ERST_ADD_VALUE = 10,
> ACPI_ERST_SUBTRACT_VALUE = 11,
> ACPI_ERST_STALL = 12,
> ACPI_ERST_STALL_WHILE_TRUE = 13,
> ACPI_ERST_SKIP_NEXT_IF_TRUE = 14,
> ACPI_ERST_GOTO = 15,
> ACPI_ERST_SET_SRC_ADDRESS_BASE = 16,
> ACPI_ERST_SET_DST_ADDRESS_BASE = 17,
> ACPI_ERST_MOVE_DATA = 18,
> ACPI_ERST_INSTRUCTION_RESERVED = 19
>};
>
>
>
>enum acpi_erst_command_status {
> ACPI_ERST_SUCCESS = 0,
> ACPI_ERST_NO_SPACE = 1,
> ACPI_ERST_NOT_AVAILABLE = 2,
> ACPI_ERST_FAILURE = 3,
> ACPI_ERST_RECORD_EMPTY = 4,
> ACPI_ERST_NOT_FOUND = 5,
> ACPI_ERST_STATUS_RESERVED = 6
>};
>
>
>
>struct acpi_erst_info {
> u16 signature;
> u8 data[48];
>};
># 998 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_fpdt {
> struct acpi_table_header header;
>};
>
>
>
>struct acpi_fpdt_header {
> u16 type;
> u8 length;
> u8 revision;
>};
>
>
>
>enum acpi_fpdt_type {
> ACPI_FPDT_TYPE_BOOT = 0,
> ACPI_FPDT_TYPE_S3PERF = 1
>};
>
>
>
>
>
>
>
>struct acpi_fpdt_boot_pointer {
> struct acpi_fpdt_header header;
> u8 reserved[4];
> u64 address;
>};
>
>
>
>struct acpi_fpdt_s3pt_pointer {
> struct acpi_fpdt_header header;
> u8 reserved[4];
> u64 address;
>};
>
>
>
>
>
>struct acpi_table_s3pt {
> u8 signature[4];
> u32 length;
>};
>
>
>
>
>
>
>
>enum acpi_s3pt_type {
> ACPI_S3PT_TYPE_RESUME = 0,
> ACPI_S3PT_TYPE_SUSPEND = 1,
> ACPI_FPDT_BOOT_PERFORMANCE = 2
>};
>
>struct acpi_s3pt_resume {
> struct acpi_fpdt_header header;
> u32 resume_count;
> u64 full_resume;
> u64 average_resume;
>};
>
>struct acpi_s3pt_suspend {
> struct acpi_fpdt_header header;
> u64 suspend_start;
> u64 suspend_end;
>};
>
>
>
>
>struct acpi_fpdt_boot {
> struct acpi_fpdt_header header;
> u8 reserved[4];
> u64 reset_end;
> u64 load_start;
> u64 startup_start;
> u64 exit_services_entry;
> u64 exit_services_exit;
>};
># 1091 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_gtdt {
> struct acpi_table_header header;
> u64 counter_block_addresss;
> u32 reserved;
> u32 secure_el1_interrupt;
> u32 secure_el1_flags;
> u32 non_secure_el1_interrupt;
> u32 non_secure_el1_flags;
> u32 virtual_timer_interrupt;
> u32 virtual_timer_flags;
> u32 non_secure_el2_interrupt;
> u32 non_secure_el2_flags;
> u64 counter_read_block_address;
> u32 platform_timer_count;
> u32 platform_timer_offset;
>};
>
>
>
>
>
>
>
>struct acpi_gtdt_el2 {
> u32 virtual_el2_timer_gsiv;
> u32 virtual_el2_timer_flags;
>};
>
>
>
>struct acpi_gtdt_header {
> u8 type;
> u16 length;
>};
>
>
>
>enum acpi_gtdt_type {
> ACPI_GTDT_TYPE_TIMER_BLOCK = 0,
> ACPI_GTDT_TYPE_WATCHDOG = 1,
> ACPI_GTDT_TYPE_RESERVED = 2
>};
>
>
>
>
>
>struct acpi_gtdt_timer_block {
> struct acpi_gtdt_header header;
> u8 reserved;
> u64 block_address;
> u32 timer_count;
> u32 timer_offset;
>};
>
>
>
>struct acpi_gtdt_timer_entry {
> u8 frame_number;
> u8 reserved[3];
> u64 base_address;
> u64 el0_base_address;
> u32 timer_interrupt;
> u32 timer_flags;
> u32 virtual_timer_interrupt;
> u32 virtual_timer_flags;
> u32 common_flags;
>};
># 1172 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_gtdt_watchdog {
> struct acpi_gtdt_header header;
> u8 reserved;
> u64 refresh_frame_address;
> u64 control_frame_address;
> u32 timer_interrupt;
> u32 timer_flags;
>};
># 1194 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_hest {
> struct acpi_table_header header;
> u32 error_source_count;
>};
>
>
>
>struct acpi_hest_header {
> u16 type;
> u16 source_id;
>};
>
>
>
>enum acpi_hest_types {
> ACPI_HEST_TYPE_IA32_CHECK = 0,
> ACPI_HEST_TYPE_IA32_CORRECTED_CHECK = 1,
> ACPI_HEST_TYPE_IA32_NMI = 2,
> ACPI_HEST_TYPE_NOT_USED3 = 3,
> ACPI_HEST_TYPE_NOT_USED4 = 4,
> ACPI_HEST_TYPE_NOT_USED5 = 5,
> ACPI_HEST_TYPE_AER_ROOT_PORT = 6,
> ACPI_HEST_TYPE_AER_ENDPOINT = 7,
> ACPI_HEST_TYPE_AER_BRIDGE = 8,
> ACPI_HEST_TYPE_GENERIC_ERROR = 9,
> ACPI_HEST_TYPE_GENERIC_ERROR_V2 = 10,
> ACPI_HEST_TYPE_IA32_DEFERRED_CHECK = 11,
> ACPI_HEST_TYPE_RESERVED = 12
>};
># 1232 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hest_ia_error_bank {
> u8 bank_number;
> u8 clear_status_on_init;
> u8 status_format;
> u8 reserved;
> u32 control_register;
> u64 control_data;
> u32 status_register;
> u32 address_register;
> u32 misc_register;
>};
>
>
>
>struct acpi_hest_aer_common {
> u16 reserved1;
> u8 flags;
> u8 enabled;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> u32 bus;
> u16 device;
> u16 function;
> u16 device_control;
> u16 reserved2;
> u32 uncorrectable_mask;
> u32 uncorrectable_severity;
> u32 correctable_mask;
> u32 advanced_capabilities;
>};
># 1279 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hest_notify {
> u8 type;
> u8 length;
> u16 config_write_enable;
> u32 poll_interval;
> u32 vector;
> u32 polling_threshold_value;
> u32 polling_threshold_window;
> u32 error_threshold_value;
> u32 error_threshold_window;
>};
>
>
>
>enum acpi_hest_notify_types {
> ACPI_HEST_NOTIFY_POLLED = 0,
> ACPI_HEST_NOTIFY_EXTERNAL = 1,
> ACPI_HEST_NOTIFY_LOCAL = 2,
> ACPI_HEST_NOTIFY_SCI = 3,
> ACPI_HEST_NOTIFY_NMI = 4,
> ACPI_HEST_NOTIFY_CMCI = 5,
> ACPI_HEST_NOTIFY_MCE = 6,
> ACPI_HEST_NOTIFY_GPIO = 7,
> ACPI_HEST_NOTIFY_SEA = 8,
> ACPI_HEST_NOTIFY_SEI = 9,
> ACPI_HEST_NOTIFY_GSIV = 10,
> ACPI_HEST_NOTIFY_SOFTWARE_DELEGATED = 11,
> ACPI_HEST_NOTIFY_RESERVED = 12
>};
># 1324 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hest_ia_machine_check {
> struct acpi_hest_header header;
> u16 reserved1;
> u8 flags;
> u8 enabled;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> u64 global_capability_data;
> u64 global_control_data;
> u8 num_hardware_banks;
> u8 reserved3[7];
>};
>
>
>
>struct acpi_hest_ia_corrected {
> struct acpi_hest_header header;
> u16 reserved1;
> u8 flags;
> u8 enabled;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> struct acpi_hest_notify notify;
> u8 num_hardware_banks;
> u8 reserved2[3];
>};
>
>
>
>struct acpi_hest_ia_nmi {
> struct acpi_hest_header header;
> u32 reserved;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> u32 max_raw_data_length;
>};
>
>
>
>
>
>struct acpi_hest_aer_root {
> struct acpi_hest_header header;
> struct acpi_hest_aer_common aer;
> u32 root_error_command;
>};
>
>
>
>struct acpi_hest_aer {
> struct acpi_hest_header header;
> struct acpi_hest_aer_common aer;
>};
>
>
>
>struct acpi_hest_aer_bridge {
> struct acpi_hest_header header;
> struct acpi_hest_aer_common aer;
> u32 uncorrectable_mask2;
> u32 uncorrectable_severity2;
> u32 advanced_capabilities2;
>};
>
>
>
>struct acpi_hest_generic {
> struct acpi_hest_header header;
> u16 related_source_id;
> u8 reserved;
> u8 enabled;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> u32 max_raw_data_length;
> struct acpi_generic_address error_status_address;
> struct acpi_hest_notify notify;
> u32 error_block_length;
>};
>
>
>
>struct acpi_hest_generic_v2 {
> struct acpi_hest_header header;
> u16 related_source_id;
> u8 reserved;
> u8 enabled;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> u32 max_raw_data_length;
> struct acpi_generic_address error_status_address;
> struct acpi_hest_notify notify;
> u32 error_block_length;
> struct acpi_generic_address read_ack_register;
> u64 read_ack_preserve;
> u64 read_ack_write;
>};
>
>
>
>struct acpi_hest_generic_status {
> u32 block_status;
> u32 raw_data_offset;
> u32 raw_data_length;
> u32 data_length;
> u32 error_severity;
>};
># 1441 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hest_generic_data {
> u8 section_type[16];
> u32 error_severity;
> u16 revision;
> u8 validation_bits;
> u8 flags;
> u32 error_data_length;
> u8 fru_id[16];
> u8 fru_text[20];
>};
>
>
>
>struct acpi_hest_generic_data_v300 {
> u8 section_type[16];
> u32 error_severity;
> u16 revision;
> u8 validation_bits;
> u8 flags;
> u32 error_data_length;
> u8 fru_id[16];
> u8 fru_text[20];
> u64 time_stamp;
>};
># 1481 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hest_ia_deferred_check {
> struct acpi_hest_header header;
> u16 reserved1;
> u8 flags;
> u8 enabled;
> u32 records_to_preallocate;
> u32 max_sections_per_record;
> struct acpi_hest_notify notify;
> u8 num_hardware_banks;
> u8 reserved2[3];
>};
># 1500 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_hmat {
> struct acpi_table_header header;
> u32 reserved;
>};
>
>
>
>enum acpi_hmat_type {
> ACPI_HMAT_TYPE_PROXIMITY = 0,
> ACPI_HMAT_TYPE_LOCALITY = 1,
> ACPI_HMAT_TYPE_CACHE = 2,
> ACPI_HMAT_TYPE_RESERVED = 3
>};
>
>struct acpi_hmat_structure {
> u16 type;
> u16 reserved;
> u32 length;
>};
>
>
>
>
>
>
>
>struct acpi_hmat_proximity_domain {
> struct acpi_hmat_structure header;
> u16 flags;
> u16 reserved1;
> u32 processor_PD;
> u32 memory_PD;
> u32 reserved2;
> u64 reserved3;
> u64 reserved4;
>};
># 1545 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hmat_locality {
> struct acpi_hmat_structure header;
> u8 flags;
> u8 data_type;
> u8 min_transfer_size;
> u8 reserved1;
> u32 number_of_initiator_Pds;
> u32 number_of_target_Pds;
> u32 reserved2;
> u64 entry_base_unit;
>};
># 1583 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_hmat_cache {
> struct acpi_hmat_structure header;
> u32 memory_PD;
> u32 reserved1;
> u64 cache_size;
> u32 cache_attributes;
> u16 reserved2;
> u16 number_of_SMBIOShandles;
>};
># 1623 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_hpet {
> struct acpi_table_header header;
> u32 id;
> struct acpi_generic_address address;
> u8 sequence;
> u16 minimum_tick;
> u8 flags;
>};
>
>
>
>
>
>
>
>enum acpi_hpet_page_protect {
> ACPI_HPET_NO_PAGE_PROTECT = 0,
> ACPI_HPET_PAGE_PROTECT4 = 1,
> ACPI_HPET_PAGE_PROTECT64 = 2
>};
># 1657 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl1.h"
>struct acpi_table_ibft {
> struct acpi_table_header header;
> u8 reserved[12];
>};
>
>
>
>struct acpi_ibft_header {
> u8 type;
> u8 version;
> u16 length;
> u8 index;
> u8 flags;
>};
>
>
>
>enum acpi_ibft_type {
> ACPI_IBFT_TYPE_NOT_USED = 0,
> ACPI_IBFT_TYPE_CONTROL = 1,
> ACPI_IBFT_TYPE_INITIATOR = 2,
> ACPI_IBFT_TYPE_NIC = 3,
> ACPI_IBFT_TYPE_TARGET = 4,
> ACPI_IBFT_TYPE_EXTENSIONS = 5,
> ACPI_IBFT_TYPE_RESERVED = 6
>};
>
>
>
>struct acpi_ibft_control {
> struct acpi_ibft_header header;
> u16 extensions;
> u16 initiator_offset;
> u16 nic0_offset;
> u16 target0_offset;
> u16 nic1_offset;
> u16 target1_offset;
>};
>
>struct acpi_ibft_initiator {
> struct acpi_ibft_header header;
> u8 sns_server[16];
> u8 slp_server[16];
> u8 primary_server[16];
> u8 secondary_server[16];
> u16 name_length;
> u16 name_offset;
>};
>
>struct acpi_ibft_nic {
> struct acpi_ibft_header header;
> u8 ip_address[16];
> u8 subnet_mask_prefix;
> u8 origin;
> u8 gateway[16];
> u8 primary_dns[16];
> u8 secondary_dns[16];
> u8 dhcp[16];
> u16 vlan;
> u8 mac_address[6];
> u16 pci_address;
> u16 name_length;
> u16 name_offset;
>};
>
>struct acpi_ibft_target {
> struct acpi_ibft_header header;
> u8 target_ip_address[16];
> u16 target_ip_socket;
> u8 target_boot_lun[8];
> u8 chap_type;
> u8 nic_association;
> u16 target_name_length;
> u16 target_name_offset;
> u16 chap_name_length;
> u16 chap_name_offset;
> u16 chap_secret_length;
> u16 chap_secret_offset;
> u16 reverse_chap_name_length;
> u16 reverse_chap_name_offset;
> u16 reverse_chap_secret_length;
> u16 reverse_chap_secret_offset;
>};
>
>
>
>#pragma pack()
># 371 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h" 1
># 59 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>#pragma pack(1)
># 82 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_aest {
> struct acpi_table_header header;
> void *node_array[];
>};
>
>
>
>struct acpi_aest_hdr {
> u8 type;
> u16 length;
> u8 reserved;
> u32 node_specific_offset;
> u32 node_interface_offset;
> u32 node_interrupt_offset;
> u32 node_interrupt_count;
> u64 timestamp_rate;
> u64 reserved1;
> u64 error_injection_rate;
>};
># 117 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>typedef struct acpi_aest_processor {
> u32 processor_id;
> u8 resource_type;
> u8 reserved;
> u8 flags;
> u8 revision;
> u64 processor_affinity;
>
>} acpi_aest_processor;
># 136 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>typedef struct acpi_aest_processor_cache {
> u32 cache_reference;
> u32 reserved;
>
>} acpi_aest_processor_cache;
># 151 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>typedef struct acpi_aest_processor_tlb {
> u32 tlb_level;
> u32 reserved;
>
>} acpi_aest_processor_tlb;
>
>
>
>typedef struct acpi_aest_processor_generic {
> u32 resource;
>
>} acpi_aest_processor_generic;
>
>
>
>typedef struct acpi_aest_memory {
> u32 srat_proximity_domain;
>
>} acpi_aest_memory;
>
>
>
>typedef struct acpi_aest_smmu {
> u32 iort_node_reference;
> u32 subcomponent_reference;
>
>} acpi_aest_smmu;
>
>
>
>typedef struct acpi_aest_vendor {
> u32 acpi_hid;
> u32 acpi_uid;
> u8 vendor_specific_data[16];
>
>} acpi_aest_vendor;
>
>
>
>typedef struct acpi_aest_gic {
> u32 interface_type;
> u32 instance_id;
>
>} acpi_aest_gic;
># 206 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>typedef struct acpi_aest_node_interface {
> u8 type;
> u8 reserved[3];
> u32 flags;
> u64 address;
> u32 error_record_index;
> u32 error_record_count;
> u64 error_record_implemented;
> u64 error_status_reporting;
> u64 addressing_mode;
>
>} acpi_aest_node_interface;
># 227 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>typedef struct acpi_aest_node_interrupt {
> u8 type;
> u8 reserved[2];
> u8 flags;
> u32 gsiv;
> u8 iort_id;
> u8 reserved1[3];
>
>} acpi_aest_node_interrupt;
># 250 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_agdi {
> struct acpi_table_header header;
> u8 flags;
> u8 reserved[3];
> u32 sdei_event;
> u32 gsiv;
>};
># 272 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_apmt {
> struct acpi_table_header header;
>};
>
>
>
>
>
>
>struct acpi_apmt_node {
> u16 length;
> u8 flags;
> u8 type;
> u32 id;
> u64 inst_primary;
> u32 inst_secondary;
> u64 base_address0;
> u64 base_address1;
> u32 ovflw_irq;
> u32 reserved;
> u32 ovflw_irq_flags;
> u32 proc_affinity;
> u32 impl_id;
>};
># 318 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>enum acpi_apmt_node_type {
> ACPI_APMT_NODE_TYPE_MC = 0x00,
> ACPI_APMT_NODE_TYPE_SMMU = 0x01,
> ACPI_APMT_NODE_TYPE_PCIE_ROOT = 0x02,
> ACPI_APMT_NODE_TYPE_ACPI = 0x03,
> ACPI_APMT_NODE_TYPE_CACHE = 0x04,
> ACPI_APMT_NODE_TYPE_COUNT
>};
># 350 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_bdat {
> struct acpi_table_header header;
> struct acpi_generic_address gas;
>};
># 364 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_iort {
> struct acpi_table_header header;
> u32 node_count;
> u32 node_offset;
> u32 reserved;
>};
>
>
>
>
>struct acpi_iort_node {
> u8 type;
> u16 length;
> u8 revision;
> u32 identifier;
> u32 mapping_count;
> u32 mapping_offset;
> char node_data[1];
>};
>
>
>
>enum acpi_iort_node_type {
> ACPI_IORT_NODE_ITS_GROUP = 0x00,
> ACPI_IORT_NODE_NAMED_COMPONENT = 0x01,
> ACPI_IORT_NODE_PCI_ROOT_COMPLEX = 0x02,
> ACPI_IORT_NODE_SMMU = 0x03,
> ACPI_IORT_NODE_SMMU_V3 = 0x04,
> ACPI_IORT_NODE_PMCG = 0x05,
> ACPI_IORT_NODE_RMR = 0x06,
>};
>
>struct acpi_iort_id_mapping {
> u32 input_base;
> u32 id_count;
> u32 output_base;
> u32 output_reference;
> u32 flags;
>};
>
>
>
>
>
>struct acpi_iort_memory_access {
> u32 cache_coherency;
> u8 hints;
> u16 reserved;
> u8 memory_flags;
>};
># 435 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_iort_its_group {
> u32 its_count;
> u32 identifiers[1];
>};
>
>struct acpi_iort_named_component {
> u32 node_flags;
> u64 memory_properties;
> u8 memory_address_limit;
> char device_name[1];
>};
>
>
>
>
>
>
>struct acpi_iort_root_complex {
> u64 memory_properties;
> u32 ats_attribute;
> u32 pci_segment_number;
> u8 memory_address_limit;
> u16 pasid_capabilities;
> u8 reserved[1];
>};
># 470 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_iort_smmu {
> u64 base_address;
> u64 span;
> u32 model;
> u32 flags;
> u32 global_interrupt_offset;
> u32 context_interrupt_count;
> u32 context_interrupt_offset;
> u32 pmu_interrupt_count;
> u32 pmu_interrupt_offset;
> u64 interrupts[1];
>};
># 499 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_iort_smmu_gsi {
> u32 nsg_irpt;
> u32 nsg_irpt_flags;
> u32 nsg_cfg_irpt;
> u32 nsg_cfg_irpt_flags;
>};
>
>struct acpi_iort_smmu_v3 {
> u64 base_address;
> u32 flags;
> u32 reserved;
> u64 vatos_address;
> u32 model;
> u32 event_gsiv;
> u32 pri_gsiv;
> u32 gerr_gsiv;
> u32 sync_gsiv;
> u32 pxm;
> u32 id_mapping_index;
>};
># 532 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_iort_pmcg {
> u64 page0_base_address;
> u32 overflow_gsiv;
> u32 node_reference;
> u64 page1_base_address;
>};
>
>struct acpi_iort_rmr {
> u32 flags;
> u32 rmr_count;
> u32 rmr_offset;
>};
># 564 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_iort_rmr_desc {
> u64 base_address;
> u64 length;
> u32 reserved;
>};
># 580 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_ivrs {
> struct acpi_table_header header;
> u32 info;
> u64 reserved;
>};
># 594 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_ivrs_header {
> u8 type;
> u8 flags;
> u16 length;
> u16 device_id;
>};
>
>
>
>enum acpi_ivrs_type {
> ACPI_IVRS_TYPE_HARDWARE1 = 0x10,
> ACPI_IVRS_TYPE_HARDWARE2 = 0x11,
> ACPI_IVRS_TYPE_HARDWARE3 = 0x40,
> ACPI_IVRS_TYPE_MEMORY1 = 0x20,
> ACPI_IVRS_TYPE_MEMORY2 = 0x21,
> ACPI_IVRS_TYPE_MEMORY3 = 0x22
>};
># 633 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_ivrs_hardware_10 {
> struct acpi_ivrs_header header;
> u16 capability_offset;
> u64 base_address;
> u16 pci_segment_group;
> u16 info;
> u32 feature_reporting;
>};
>
>
>
>struct acpi_ivrs_hardware_11 {
> struct acpi_ivrs_header header;
> u16 capability_offset;
> u64 base_address;
> u16 pci_segment_group;
> u16 info;
> u32 attributes;
> u64 efr_register_image;
> u64 reserved;
>};
># 666 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_ivrs_de_header {
> u8 type;
> u16 id;
> u8 data_setting;
>};
>
>
>
>
>
>
>
>enum acpi_ivrs_device_entry_type {
>
>
> ACPI_IVRS_TYPE_PAD4 = 0,
> ACPI_IVRS_TYPE_ALL = 1,
> ACPI_IVRS_TYPE_SELECT = 2,
> ACPI_IVRS_TYPE_START = 3,
> ACPI_IVRS_TYPE_END = 4,
>
>
>
> ACPI_IVRS_TYPE_PAD8 = 64,
> ACPI_IVRS_TYPE_NOT_USED = 65,
> ACPI_IVRS_TYPE_ALIAS_SELECT = 66,
> ACPI_IVRS_TYPE_ALIAS_START = 67,
> ACPI_IVRS_TYPE_EXT_SELECT = 70,
> ACPI_IVRS_TYPE_EXT_START = 71,
> ACPI_IVRS_TYPE_SPECIAL = 72,
>
>
>
> ACPI_IVRS_TYPE_HID = 240
>};
># 713 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_ivrs_device4 {
> struct acpi_ivrs_de_header header;
>};
>
>
>
>struct acpi_ivrs_device8a {
> struct acpi_ivrs_de_header header;
> u8 reserved1;
> u16 used_id;
> u8 reserved2;
>};
>
>
>
>struct acpi_ivrs_device8b {
> struct acpi_ivrs_de_header header;
> u32 extended_data;
>};
>
>
>
>
>
>
>
>struct acpi_ivrs_device8c {
> struct acpi_ivrs_de_header header;
> u8 handle;
> u16 used_id;
> u8 variety;
>};
># 753 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_ivrs_device_hid {
> struct acpi_ivrs_de_header header;
> u64 acpi_hid;
> u64 acpi_cid;
> u8 uid_type;
> u8 uid_length;
>};
># 769 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_ivrs_memory {
> struct acpi_ivrs_header header;
> u16 aux_data;
> u64 reserved;
> u64 start_address;
> u64 memory_length;
>};
># 785 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_lpit {
> struct acpi_table_header header;
>};
>
>
>
>struct acpi_lpit_header {
> u32 type;
> u32 length;
> u16 unique_id;
> u16 reserved;
> u32 flags;
>};
>
>
>
>enum acpi_lpit_type {
> ACPI_LPIT_TYPE_NATIVE_CSTATE = 0x00,
> ACPI_LPIT_TYPE_RESERVED = 0x01
>};
># 817 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_lpit_native {
> struct acpi_lpit_header header;
> struct acpi_generic_address entry_trigger;
> u32 residency;
> u32 latency;
> struct acpi_generic_address residency_counter;
> u64 counter_frequency;
>};
># 833 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_madt {
> struct acpi_table_header header;
> u32 address;
> u32 flags;
>};
># 850 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>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_MULTIPROC_WAKEUP = 16,
> ACPI_MADT_TYPE_RESERVED = 17,
> ACPI_MADT_TYPE_OEM_RESERVED = 0x80
>};
>
>
>
>
>
>
>
>struct acpi_madt_local_apic {
> struct acpi_subtable_header header;
> u8 processor_id;
> u8 id;
> u32 lapic_flags;
>};
>
>
>
>struct acpi_madt_io_apic {
> struct acpi_subtable_header header;
> u8 id;
> u8 reserved;
> u32 address;
> u32 global_irq_base;
>};
>
>
>
>struct acpi_madt_interrupt_override {
> struct acpi_subtable_header header;
> u8 bus;
> u8 source_irq;
> u32 global_irq;
> u16 inti_flags;
>};
>
>
>
>struct acpi_madt_nmi_source {
> struct acpi_subtable_header header;
> u16 inti_flags;
> u32 global_irq;
>};
>
>
>
>struct acpi_madt_local_apic_nmi {
> struct acpi_subtable_header header;
> u8 processor_id;
> u16 inti_flags;
> u8 lint;
>};
>
>
>
>struct acpi_madt_local_apic_override {
> struct acpi_subtable_header header;
> u16 reserved;
> u64 address;
>};
>
>
>
>struct acpi_madt_io_sapic {
> struct acpi_subtable_header header;
> u8 id;
> u8 reserved;
> u32 global_irq_base;
> u64 address;
>};
>
>
>
>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];
>};
>
>
>
>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_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_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[1];
> u16 spe_interrupt;
>};
># 1020 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>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];
>};
>
>
>
>enum acpi_madt_gic_version {
> ACPI_MADT_GIC_VERSION_NONE = 0,
> ACPI_MADT_GIC_VERSION_V1 = 1,
> ACPI_MADT_GIC_VERSION_V2 = 2,
> ACPI_MADT_GIC_VERSION_V3 = 3,
> ACPI_MADT_GIC_VERSION_V4 = 4,
> ACPI_MADT_GIC_VERSION_RESERVED = 5
>};
>
>
>
>struct acpi_madt_generic_msi_frame {
> struct acpi_subtable_header header;
> u16 reserved;
> u32 msi_frame_id;
> u64 base_address;
> u32 flags;
> u16 spi_count;
> u16 spi_base;
>};
>
>
>
>
>
>
>
>struct acpi_madt_generic_redistributor {
> struct acpi_subtable_header header;
> u16 reserved;
> u64 base_address;
> u32 length;
>};
>
>
>
>struct acpi_madt_generic_translator {
> struct acpi_subtable_header header;
> u16 reserved;
> u32 translation_id;
> u64 base_address;
> u32 reserved2;
>};
>
>
>
>struct acpi_madt_multiproc_wakeup {
> struct acpi_subtable_header header;
> u16 mailbox_version;
> u32 reserved;
> u64 base_address;
>};
>
>
>
>
>struct acpi_madt_multiproc_wakeup_mailbox {
> u16 command;
> u16 reserved;
> u32 apic_id;
> u64 wakeup_vector;
> u8 reserved_os[2032];
> u8 reserved_firmware[2048];
>};
>
>
>
>
>
>struct acpi_madt_oem_data {
> u8 oem_data[0];
>};
># 1140 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_mcfg {
> struct acpi_table_header header;
> u8 reserved[8];
>};
>
>
>
>struct acpi_mcfg_allocation {
> u64 address;
> u16 pci_segment;
> u8 start_bus_number;
> u8 end_bus_number;
> u32 reserved;
>};
># 1165 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_mchi {
> struct acpi_table_header header;
> u8 interface_type;
> u8 protocol;
> u64 protocol_data;
> u8 interrupt_type;
> u8 gpe;
> u8 pci_device_flag;
> u32 global_interrupt;
> struct acpi_generic_address control_register;
> u8 pci_segment;
> u8 pci_bus;
> u8 pci_device;
> u8 pci_function;
>};
># 1196 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_mpst {
> struct acpi_table_header header;
>  u8 channel_id; u8 reserved1[3]; u16 power_node_count; u16 reserved2;
>};
>
>
>
>struct acpi_mpst_channel {
> u8 channel_id; u8 reserved1[3]; u16 power_node_count; u16 reserved2;
>};
>
>
>
>struct acpi_mpst_power_node {
> u8 flags;
> u8 reserved1;
> u16 node_id;
> u32 length;
> u64 range_address;
> u64 range_length;
> u32 num_power_states;
> u32 num_physical_components;
>};
># 1228 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_mpst_power_state {
> u8 power_state;
> u8 info_index;
>};
>
>
>
>struct acpi_mpst_component {
> u16 component_id;
>};
>
>
>
>struct acpi_mpst_data_hdr {
> u16 characteristics_count;
> u16 reserved;
>};
>
>struct acpi_mpst_power_data {
> u8 structure_id;
> u8 flags;
> u16 reserved1;
> u32 average_power;
> u32 power_saving;
> u64 exit_latency;
> u64 reserved2;
>};
># 1264 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_mpst_shared {
> u32 signature;
> u16 pcc_command;
> u16 pcc_status;
> u32 command_register;
> u32 status_register;
> u32 power_state_id;
> u32 power_node_id;
> u64 energy_consumed;
> u64 average_power;
>};
># 1283 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_msct {
> struct acpi_table_header header;
> u32 proximity_offset;
> u32 max_proximity_domains;
> u32 max_clock_domains;
> u64 max_address;
>};
>
>
>
>struct acpi_msct_proximity {
> u8 revision;
> u8 length;
> u32 range_start;
> u32 range_end;
> u32 processor_capacity;
> u64 memory_capacity;
>};
># 1313 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_msdm {
> struct acpi_table_header header;
>};
># 1324 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_nfit {
> struct acpi_table_header header;
> u32 reserved;
>};
>
>
>
>struct acpi_nfit_header {
> u16 type;
> u16 length;
>};
>
>
>
>enum acpi_nfit_type {
> ACPI_NFIT_TYPE_SYSTEM_ADDRESS = 0,
> ACPI_NFIT_TYPE_MEMORY_MAP = 1,
> ACPI_NFIT_TYPE_INTERLEAVE = 2,
> ACPI_NFIT_TYPE_SMBIOS = 3,
> ACPI_NFIT_TYPE_CONTROL_REGION = 4,
> ACPI_NFIT_TYPE_DATA_REGION = 5,
> ACPI_NFIT_TYPE_FLUSH_ADDRESS = 6,
> ACPI_NFIT_TYPE_CAPABILITIES = 7,
> ACPI_NFIT_TYPE_RESERVED = 8
>};
>
>
>
>
>
>
>
>struct acpi_nfit_system_address {
> struct acpi_nfit_header header;
> u16 range_index;
> u16 flags;
> u32 reserved;
> u32 proximity_domain;
> u8 range_guid[16];
> u64 address;
> u64 length;
> u64 memory_mapping;
> u64 location_cookie;
>};
># 1379 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nfit_memory_map {
> struct acpi_nfit_header header;
> u32 device_handle;
> u16 physical_id;
> u16 region_id;
> u16 range_index;
> u16 region_index;
> u64 region_size;
> u64 region_offset;
> u64 address;
> u16 interleave_index;
> u16 interleave_ways;
> u16 flags;
> u16 reserved;
>};
># 1407 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nfit_interleave {
> struct acpi_nfit_header header;
> u16 interleave_index;
> u16 reserved;
> u32 line_count;
> u32 line_size;
> u32 line_offset[1];
>};
>
>
>
>struct acpi_nfit_smbios {
> struct acpi_nfit_header header;
> u32 reserved;
> u8 data[1];
>};
>
>
>
>struct acpi_nfit_control_region {
> struct acpi_nfit_header header;
> u16 region_index;
> u16 vendor_id;
> u16 device_id;
> u16 revision_id;
> u16 subsystem_vendor_id;
> u16 subsystem_device_id;
> u16 subsystem_revision_id;
> u8 valid_fields;
> u8 manufacturing_location;
> u16 manufacturing_date;
> u8 reserved[2];
> u32 serial_number;
> u16 code;
> u16 windows;
> u64 window_size;
> u64 command_offset;
> u64 command_size;
> u64 status_offset;
> u64 status_size;
> u16 flags;
> u8 reserved1[6];
>};
># 1461 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nfit_data_region {
> struct acpi_nfit_header header;
> u16 region_index;
> u16 windows;
> u64 offset;
> u64 size;
> u64 capacity;
> u64 start_address;
>};
>
>
>
>struct acpi_nfit_flush_address {
> struct acpi_nfit_header header;
> u32 device_handle;
> u16 hint_count;
> u8 reserved[6];
> u64 hint_address[1];
>};
>
>
>
>struct acpi_nfit_capabilities {
> struct acpi_nfit_header header;
> u8 highest_capability;
> u8 reserved[3];
> u32 capabilities;
> u32 reserved2;
>};
># 1500 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct nfit_device_handle {
> u32 handle;
>};
># 1555 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_nhlt {
> struct acpi_table_header header;
> u8 endpoint_count;
>};
>
>struct acpi_nhlt_endpoint {
> u32 descriptor_length;
> u8 link_type;
> u8 instance_id;
> u16 vendor_id;
> u16 device_id;
> u16 revision_id;
> u32 subsystem_id;
> u8 device_type;
> u8 direction;
> u8 virtual_bus_id;
>};
># 1614 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nhlt_device_specific_config {
> u32 capabilities_size;
> u8 virtual_slot;
> u8 config_type;
>};
>
>struct acpi_nhlt_device_specific_config_a {
> u32 capabilities_size;
> u8 virtual_slot;
> u8 config_type;
> u8 array_type;
>};
># 1634 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nhlt_device_specific_config_b {
> u32 capabilities_size;
>};
>
>struct acpi_nhlt_device_specific_config_c {
> u32 capabilities_size;
> u8 virtual_slot;
>};
>
>struct acpi_nhlt_render_device_specific_config {
> u32 capabilities_size;
> u8 virtual_slot;
>};
>
>struct acpi_nhlt_wave_extensible {
> u16 format_tag;
> u16 channel_count;
> u32 samples_per_sec;
> u32 avg_bytes_per_sec;
> u16 block_align;
> u16 bits_per_sample;
> u16 extra_format_size;
> u16 valid_bits_per_sample;
> u32 channel_mask;
> u8 sub_format_guid[16];
>};
># 1682 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nhlt_format_config {
> struct acpi_nhlt_wave_extensible format;
> u32 capability_size;
> u8 capabilities[];
>};
>
>struct acpi_nhlt_formats_config {
> u8 formats_count;
>};
>
>struct acpi_nhlt_device_specific_hdr {
> u8 virtual_slot;
> u8 config_type;
>};
>
>
>
>
>
>
>
>struct acpi_nhlt_mic_device_specific_config {
> struct acpi_nhlt_device_specific_hdr device_config;
> u8 array_type_ext;
>};
># 1723 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nhlt_vendor_mic_count {
> u8 microphone_count;
>};
>
>struct acpi_nhlt_vendor_mic_config {
> u8 type;
> u8 panel;
> u16 speaker_position_distance;
> u16 horizontal_offset;
> u16 vertical_offset;
> u8 frequency_low_band;
> u8 frequency_high_band;
> u16 direction_angle;
> u16 elevation_angle;
> u16 work_vertical_angle_begin;
> u16 work_vertical_angle_end;
> u16 work_horizontal_angle_begin;
> u16 work_horizontal_angle_end;
>};
># 1765 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_nhlt_vendor_mic_device_specific_config {
> struct acpi_nhlt_mic_device_specific_config mic_array_device_config;
> u8 number_of_microphones;
> struct acpi_nhlt_vendor_mic_config mic_config[];
>};
>
>
>
>struct acpi_nhlt_mic_snr_sensitivity_extension {
> u32 SNR;
> u32 sensitivity;
>};
>
>
>
>struct acpi_nhlt_render_feedback_device_specific_config {
> u8 feedback_virtual_slot;
> u16 feedback_channels;
> u16 feedback_valid_bits_per_sample;
>};
>
>
>
>struct acpi_nhlt_device_info_count {
> u8 structure_count;
>};
>
>struct acpi_nhlt_device_info {
> u8 device_id[16];
> u8 device_instance_id;
> u8 device_port_id;
>};
># 1805 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_pcct {
> struct acpi_table_header header;
> u32 flags;
> u64 reserved;
>};
>
>
>
>
>
>
>
>enum acpi_pcct_type {
> ACPI_PCCT_TYPE_GENERIC_SUBSPACE = 0,
> ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE = 1,
> ACPI_PCCT_TYPE_HW_REDUCED_SUBSPACE_TYPE2 = 2,
> ACPI_PCCT_TYPE_EXT_PCC_MASTER_SUBSPACE = 3,
> ACPI_PCCT_TYPE_EXT_PCC_SLAVE_SUBSPACE = 4,
> ACPI_PCCT_TYPE_HW_REG_COMM_SUBSPACE = 5,
> ACPI_PCCT_TYPE_RESERVED = 6
>};
>
>
>
>
>
>
>
>struct acpi_pcct_subspace {
> struct acpi_subtable_header header;
> u8 reserved[6];
> u64 base_address;
> u64 length;
> struct acpi_generic_address doorbell_register;
> u64 preserve_mask;
> u64 write_mask;
> u32 latency;
> u32 max_access_rate;
> u16 min_turnaround_time;
>};
>
>
>
>struct acpi_pcct_hw_reduced {
> struct acpi_subtable_header header;
> u32 platform_interrupt;
> u8 flags;
> u8 reserved;
> u64 base_address;
> u64 length;
> struct acpi_generic_address doorbell_register;
> u64 preserve_mask;
> u64 write_mask;
> u32 latency;
> u32 max_access_rate;
> u16 min_turnaround_time;
>};
>
>
>
>struct acpi_pcct_hw_reduced_type2 {
> struct acpi_subtable_header header;
> u32 platform_interrupt;
> u8 flags;
> u8 reserved;
> u64 base_address;
> u64 length;
> struct acpi_generic_address doorbell_register;
> u64 preserve_mask;
> u64 write_mask;
> u32 latency;
> u32 max_access_rate;
> u16 min_turnaround_time;
> struct acpi_generic_address platform_ack_register;
> u64 ack_preserve_mask;
> u64 ack_write_mask;
>};
>
>
>
>struct acpi_pcct_ext_pcc_master {
> struct acpi_subtable_header header;
> u32 platform_interrupt;
> u8 flags;
> u8 reserved1;
> u64 base_address;
> u32 length;
> struct acpi_generic_address doorbell_register;
> u64 preserve_mask;
> u64 write_mask;
> u32 latency;
> u32 max_access_rate;
> u32 min_turnaround_time;
> struct acpi_generic_address platform_ack_register;
> u64 ack_preserve_mask;
> u64 ack_set_mask;
> u64 reserved2;
> struct acpi_generic_address cmd_complete_register;
> u64 cmd_complete_mask;
> struct acpi_generic_address cmd_update_register;
> u64 cmd_update_preserve_mask;
> u64 cmd_update_set_mask;
> struct acpi_generic_address error_status_register;
> u64 error_status_mask;
>};
>
>
>
>struct acpi_pcct_ext_pcc_slave {
> struct acpi_subtable_header header;
> u32 platform_interrupt;
> u8 flags;
> u8 reserved1;
> u64 base_address;
> u32 length;
> struct acpi_generic_address doorbell_register;
> u64 preserve_mask;
> u64 write_mask;
> u32 latency;
> u32 max_access_rate;
> u32 min_turnaround_time;
> struct acpi_generic_address platform_ack_register;
> u64 ack_preserve_mask;
> u64 ack_set_mask;
> u64 reserved2;
> struct acpi_generic_address cmd_complete_register;
> u64 cmd_complete_mask;
> struct acpi_generic_address cmd_update_register;
> u64 cmd_update_preserve_mask;
> u64 cmd_update_set_mask;
> struct acpi_generic_address error_status_register;
> u64 error_status_mask;
>};
>
>
>
>struct acpi_pcct_hw_reg {
> struct acpi_subtable_header header;
> u16 version;
> u64 base_address;
> u64 length;
> struct acpi_generic_address doorbell_register;
> u64 doorbell_preserve;
> u64 doorbell_write;
> struct acpi_generic_address cmd_complete_register;
> u64 cmd_complete_mask;
> struct acpi_generic_address error_status_register;
> u64 error_status_mask;
> u32 nominal_latency;
> u32 min_turnaround_time;
>};
># 1968 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_pcct_shared_memory {
> u32 signature;
> u16 command;
> u16 status;
>};
>
>
>
>struct acpi_pcct_ext_pcc_shared_memory {
> u32 signature;
> u32 flags;
> u32 length;
> u32 command;
>};
># 1990 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_pdtt {
> struct acpi_table_header header;
> u8 trigger_count;
> u8 reserved[3];
> u32 array_offset;
>};
>
>
>
>
>
>
>struct acpi_pdtt_channel {
> u8 subchannel_id;
> u8 flags;
>};
># 2020 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_phat {
> struct acpi_table_header header;
>};
>
>
>
>struct acpi_phat_header {
> u16 type;
> u16 length;
> u8 revision;
>};
># 2044 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_phat_version_data {
> struct acpi_phat_header header;
> u8 reserved[3];
> u32 element_count;
>};
>
>struct acpi_phat_version_element {
> u8 guid[16];
> u64 version_value;
> u32 producer_id;
>};
>
>
>
>struct acpi_phat_health_data {
> struct acpi_phat_header header;
> u8 reserved[2];
> u8 health;
> u8 device_guid[16];
> u32 device_specific_offset;
>};
># 2080 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_pmtt {
> struct acpi_table_header header;
> u32 memory_device_count;
>
>
>
>
>};
>
>
>
>struct acpi_pmtt_header {
> u8 type;
> u8 reserved1;
> u16 length;
> u16 flags;
> u16 reserved2;
> u32 memory_device_count;
>
>
>
>
>
>};
># 2125 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_pmtt_socket {
> struct acpi_pmtt_header header;
> u16 socket_id;
> u16 reserved;
>};
>
>
>
>
>
>
>
>struct acpi_pmtt_controller {
> struct acpi_pmtt_header header;
> u16 controller_id;
> u16 reserved;
>};
>
>
>
>
>
>
>
>struct acpi_pmtt_physical_component {
> struct acpi_pmtt_header header;
> u32 bios_handle;
>};
>
>
>
>struct acpi_pmtt_vendor_specific {
> struct acpi_pmtt_header header;
> u8 type_uuid[16];
> u8 specific[];
>
>
>
>
>
>};
># 2174 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_pptt {
> struct acpi_table_header header;
>};
>
>
>
>enum acpi_pptt_type {
> ACPI_PPTT_TYPE_PROCESSOR = 0,
> ACPI_PPTT_TYPE_CACHE = 1,
> ACPI_PPTT_TYPE_ID = 2,
> ACPI_PPTT_TYPE_RESERVED = 3
>};
>
>
>
>struct acpi_pptt_processor {
> struct acpi_subtable_header header;
> u16 reserved;
> u32 flags;
> u32 parent;
> u32 acpi_processor_id;
> u32 number_of_priv_resources;
>};
># 2208 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_pptt_cache {
> struct acpi_subtable_header header;
> u16 reserved;
> u32 flags;
> u32 next_level_of_cache;
> u32 size;
> u32 number_of_sets;
> u8 associativity;
> u8 attributes;
> u16 line_size;
>};
>
>
>
>struct acpi_pptt_cache_v1 {
> u32 cache_id;
>};
># 2259 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_pptt_id {
> struct acpi_subtable_header header;
> u16 reserved;
> u32 vendor_id;
> u64 level1_id;
> u64 level2_id;
> u16 major_rev;
> u16 minor_rev;
> u16 spin_rev;
>};
># 2277 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_prmt {
> struct acpi_table_header header;
>};
>
>struct acpi_table_prmt_header {
> u8 platform_guid[16];
> u32 module_info_offset;
> u32 module_info_count;
>};
>
>struct acpi_prmt_module_header {
> u16 revision;
> u16 length;
>};
>
>struct acpi_prmt_module_info {
> u16 revision;
> u16 length;
> u8 module_guid[16];
> u16 major_rev;
> u16 minor_rev;
> u16 handler_info_count;
> u32 handler_info_offset;
> u64 mmio_list_pointer;
>};
>
>struct acpi_prmt_handler_info {
> u16 revision;
> u16 length;
> u8 handler_guid[16];
> u64 handler_address;
> u64 static_data_buffer_address;
> u64 acpi_param_buffer_address;
>};
># 2319 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_rasf {
> struct acpi_table_header header;
> u8 channel_id[12];
>};
>
>
>
>struct acpi_rasf_shared_memory {
> u32 signature;
> u16 command;
> u16 status;
> u16 version;
> u8 capabilities[16];
> u8 set_capabilities[16];
> u16 num_parameter_blocks;
> u32 set_capabilities_status;
>};
>
>
>
>struct acpi_rasf_parameter_block {
> u16 type;
> u16 version;
> u16 length;
>};
>
>
>
>struct acpi_rasf_patrol_scrub_parameter {
> struct acpi_rasf_parameter_block header;
> u16 patrol_scrub_command;
> u64 requested_address_range[2];
> u64 actual_address_range[2];
> u16 flags;
> u8 requested_speed;
>};
># 2366 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>enum acpi_rasf_commands {
> ACPI_RASF_EXECUTE_RASF_COMMAND = 1
>};
>
>
>
>enum acpi_rasf_capabiliities {
> ACPI_HW_PATROL_SCRUB_SUPPORTED = 0,
> ACPI_SW_PATROL_SCRUB_EXPOSED = 1
>};
>
>
>
>enum acpi_rasf_patrol_scrub_commands {
> ACPI_RASF_GET_PATROL_PARAMETERS = 1,
> ACPI_RASF_START_PATROL_SCRUBBER = 2,
> ACPI_RASF_STOP_PATROL_SCRUBBER = 3
>};
>
>
>
>
>
>
>
>enum acpi_rasf_status {
> ACPI_RASF_SUCCESS = 0,
> ACPI_RASF_NOT_VALID = 1,
> ACPI_RASF_NOT_SUPPORTED = 2,
> ACPI_RASF_BUSY = 3,
> ACPI_RASF_FAILED = 4,
> ACPI_RASF_ABORTED = 5,
> ACPI_RASF_INVALID_DATA = 6
>};
># 2418 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_rgrt {
> struct acpi_table_header header;
> u16 version;
> u8 image_type;
> u8 reserved;
> u8 image[];
>};
>
>
>
>enum acpi_rgrt_image_type {
> ACPI_RGRT_TYPE_RESERVED0 = 0,
> ACPI_RGRT_IMAGE_TYPE_PNG = 1,
> ACPI_RGRT_TYPE_RESERVED = 2
>};
># 2441 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_sbst {
> struct acpi_table_header header;
> u32 warning_level;
> u32 low_level;
> u32 critical_level;
>};
># 2457 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_sdei {
> struct acpi_table_header header;
>};
># 2468 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_sdev {
> struct acpi_table_header header;
>};
>
>struct acpi_sdev_header {
> u8 type;
> u8 flags;
> u16 length;
>};
>
>
>
>enum acpi_sdev_type {
> ACPI_SDEV_TYPE_NAMESPACE_DEVICE = 0,
> ACPI_SDEV_TYPE_PCIE_ENDPOINT_DEVICE = 1,
> ACPI_SDEV_TYPE_RESERVED = 2
>};
># 2497 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_sdev_namespace {
> struct acpi_sdev_header header;
> u16 device_id_offset;
> u16 device_id_length;
> u16 vendor_data_offset;
> u16 vendor_data_length;
>};
>
>struct acpi_sdev_secure_component {
> u16 secure_component_offset;
> u16 secure_component_length;
>};
>
>
>
>
>struct acpi_sdev_component {
> struct acpi_sdev_header header;
>};
>
>
>
>enum acpi_sac_type {
> ACPI_SDEV_TYPE_ID_COMPONENT = 0,
> ACPI_SDEV_TYPE_MEM_COMPONENT = 1
>};
>
>struct acpi_sdev_id_component {
> struct acpi_sdev_header header;
> u16 hardware_id_offset;
> u16 hardware_id_length;
> u16 subsystem_id_offset;
> u16 subsystem_id_length;
> u16 hardware_revision;
> u8 hardware_rev_present;
> u8 class_code_present;
> u8 pci_base_class;
> u8 pci_sub_class;
> u8 pci_programming_xface;
>};
>
>struct acpi_sdev_mem_component {
> struct acpi_sdev_header header;
> u32 reserved;
> u64 memory_base_address;
> u64 memory_length;
>};
>
>
>
>struct acpi_sdev_pcie {
> struct acpi_sdev_header header;
> u16 segment;
> u16 start_bus;
> u16 path_offset;
> u16 path_length;
> u16 vendor_data_offset;
> u16 vendor_data_length;
>};
>
>
>
>struct acpi_sdev_pcie_path {
> u8 device;
> u8 function;
>};
># 2573 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_svkl {
> struct acpi_table_header header;
> u32 count;
>};
>
>struct acpi_svkl_key {
> u16 type;
> u16 format;
> u32 size;
> u64 address;
>};
>
>enum acpi_svkl_type {
> ACPI_SVKL_TYPE_MAIN_STORAGE = 0,
> ACPI_SVKL_TYPE_RESERVED = 1
>};
>
>enum acpi_svkl_format {
> ACPI_SVKL_FORMAT_RAW_BINARY = 0,
> ACPI_SVKL_FORMAT_RESERVED = 1
>};
># 2604 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl2.h"
>struct acpi_table_tdel {
> struct acpi_table_header header;
> u32 reserved;
> u64 log_area_minimum_length;
> u64 log_area_start_address;
>};
>
>
>
>#pragma pack()
># 372 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h" 1
># 50 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>#pragma pack(1)
># 75 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_slic {
> struct acpi_table_header header;
>};
># 86 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_slit {
> struct acpi_table_header header;
> u64 locality_count;
> u8 entry[1];
>};
># 102 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_spcr {
> struct acpi_table_header header;
> u8 interface_type;
> u8 reserved[3];
> struct acpi_generic_address serial_port;
> u8 interrupt_type;
> u8 pc_interrupt;
> u32 interrupt;
> u8 baud_rate;
> u8 parity;
> u8 stop_bits;
> u8 flow_control;
> u8 terminal_type;
> u8 reserved1;
> u16 pci_device_id;
> u16 pci_vendor_id;
> u8 pci_bus;
> u8 pci_device;
> u8 pci_function;
> u32 pci_flags;
> u8 pci_segment;
> u32 reserved2;
>};
># 143 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_spmi {
> struct acpi_table_header header;
> u8 interface_type;
> u8 reserved;
> u16 spec_revision;
> u8 interrupt_type;
> u8 gpe_number;
> u8 reserved1;
> u8 pci_device_flag;
> u32 interrupt;
> struct acpi_generic_address ipmi_register;
> u8 pci_segment;
> u8 pci_bus;
> u8 pci_device;
> u8 pci_function;
> u8 reserved2;
>};
>
>
>
>enum acpi_spmi_interface_types {
> ACPI_SPMI_NOT_USED = 0,
> ACPI_SPMI_KEYBOARD = 1,
> ACPI_SPMI_SMI = 2,
> ACPI_SPMI_BLOCK_TRANSFER = 3,
> ACPI_SPMI_SMBUS = 4,
> ACPI_SPMI_RESERVED = 5
>};
># 179 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_srat {
> struct acpi_table_header header;
> u32 table_revision;
> u64 reserved;
>};
>
>
>
>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_GIC_ITS_AFFINITY = 4,
> ACPI_SRAT_TYPE_GENERIC_AFFINITY = 5,
> ACPI_SRAT_TYPE_GENERIC_PORT_AFFINITY = 6,
> ACPI_SRAT_TYPE_RESERVED = 7
>};
>
>
>
>
>
>
>
>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;
>};
># 239 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>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_srat_gicc_affinity {
> struct acpi_subtable_header header;
> u32 proximity_domain;
> u32 acpi_processor_uid;
> u32 flags;
> u32 clock_domain;
>};
>
>
>
>
>
>
>
>struct acpi_srat_gic_its_affinity {
> struct acpi_subtable_header header;
> u32 proximity_domain;
> u16 reserved;
> u32 its_id;
>};
>
>
>
>
>
>
>
>struct acpi_srat_generic_affinity {
> struct acpi_subtable_header header;
> u8 reserved;
> u8 device_handle_type;
> u32 proximity_domain;
> u8 device_handle[16];
> u32 flags;
> u32 reserved1;
>};
># 307 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_stao {
> struct acpi_table_header header;
> u8 ignore_uart;
>};
># 329 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_tcpa_hdr {
> struct acpi_table_header header;
> u16 platform_class;
>};
># 341 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_tcpa_client {
> u32 minimum_log_length;
> u64 log_address;
>};
>
>struct acpi_table_tcpa_server {
> u16 reserved;
> u64 minimum_log_length;
> u64 log_address;
> u16 spec_revision;
> u8 device_flags;
> u8 interrupt_flags;
> u8 gpe_number;
> u8 reserved2[3];
> u32 global_interrupt;
> struct acpi_generic_address address;
> u32 reserved3;
> struct acpi_generic_address config_address;
> u8 group;
> u8 bus;
> u8 device;
> u8 function;
>};
># 393 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_tpm23 {
> struct acpi_table_header header;
> u32 reserved;
> u64 control_address;
> u32 start_method;
>};
># 408 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_tmp23_trailer {
> u32 reserved;
>};
>
>
>
>struct acpi_table_tpm2 {
> struct acpi_table_header header;
> u16 platform_class;
> u16 reserved;
> u64 control_address;
> u32 start_method;
>
>
>};
>
>
>struct acpi_tpm2_phy {
> u8 start_method_specific[12];
> u32 log_area_minimum_length;
> u64 log_area_start_address;
>};
># 449 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_tpm2_trailer {
> u8 method_parameters[12];
> u32 minimum_log_length;
> u64 log_address;
>};
>
>
>
>
>
>
>
>struct acpi_tpm2_arm_smc {
> u32 global_interrupt;
> u8 interrupt_flags;
> u8 operation_flags;
> u16 reserved;
> u32 function_id;
>};
># 487 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_uefi {
> struct acpi_table_header header;
> u8 identifier[16];
> u16 data_offset;
>};
># 500 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_viot {
> struct acpi_table_header header;
> u16 node_count;
> u16 node_offset;
> u8 reserved[8];
>};
>
>
>
>struct acpi_viot_header {
> u8 type;
> u8 reserved;
> u16 length;
>};
>
>
>
>enum acpi_viot_node_type {
> ACPI_VIOT_NODE_PCI_RANGE = 0x01,
> ACPI_VIOT_NODE_MMIO = 0x02,
> ACPI_VIOT_NODE_VIRTIO_IOMMU_PCI = 0x03,
> ACPI_VIOT_NODE_VIRTIO_IOMMU_MMIO = 0x04,
> ACPI_VIOT_RESERVED = 0x05
>};
>
>
>
>struct acpi_viot_pci_range {
> struct acpi_viot_header header;
> u32 endpoint_start;
> u16 segment_start;
> u16 segment_end;
> u16 bdf_start;
> u16 bdf_end;
> u16 output_node;
> u8 reserved[6];
>};
>
>struct acpi_viot_mmio {
> struct acpi_viot_header header;
> u32 endpoint;
> u64 base_address;
> u16 output_node;
> u8 reserved[6];
>};
>
>struct acpi_viot_virtio_iommu_pci {
> struct acpi_viot_header header;
> u16 segment;
> u16 bdf;
> u8 reserved[8];
>};
>
>struct acpi_viot_virtio_iommu_mmio {
> struct acpi_viot_header header;
> u8 reserved[4];
> u64 base_address;
>};
># 568 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_waet {
> struct acpi_table_header header;
> u32 flags;
>};
># 588 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_wdat {
> struct acpi_table_header header;
> u32 header_length;
> u16 pci_segment;
> u8 pci_bus;
> u8 pci_device;
> u8 pci_function;
> u8 reserved[3];
> u32 timer_period;
> u32 max_count;
> u32 min_count;
> u8 flags;
> u8 reserved2[3];
> u32 entries;
>};
># 611 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_wdat_entry {
> u8 action;
> u8 instruction;
> u16 reserved;
> struct acpi_generic_address register_region;
> u32 value;
> u32 mask;
>};
>
>
>
>enum acpi_wdat_actions {
> ACPI_WDAT_RESET = 1,
> ACPI_WDAT_GET_CURRENT_COUNTDOWN = 4,
> ACPI_WDAT_GET_COUNTDOWN = 5,
> ACPI_WDAT_SET_COUNTDOWN = 6,
> ACPI_WDAT_GET_RUNNING_STATE = 8,
> ACPI_WDAT_SET_RUNNING_STATE = 9,
> ACPI_WDAT_GET_STOPPED_STATE = 10,
> ACPI_WDAT_SET_STOPPED_STATE = 11,
> ACPI_WDAT_GET_REBOOT = 16,
> ACPI_WDAT_SET_REBOOT = 17,
> ACPI_WDAT_GET_SHUTDOWN = 18,
> ACPI_WDAT_SET_SHUTDOWN = 19,
> ACPI_WDAT_GET_STATUS = 32,
> ACPI_WDAT_SET_STATUS = 33,
> ACPI_WDAT_ACTION_RESERVED = 34
>};
>
>
>
>enum acpi_wdat_instructions {
> ACPI_WDAT_READ_VALUE = 0,
> ACPI_WDAT_READ_COUNTDOWN = 1,
> ACPI_WDAT_WRITE_VALUE = 2,
> ACPI_WDAT_WRITE_COUNTDOWN = 3,
> ACPI_WDAT_INSTRUCTION_RESERVED = 4,
> ACPI_WDAT_PRESERVE_REGISTER = 0x80
>};
># 661 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_wddt {
> struct acpi_table_header header;
> u16 spec_version;
> u16 table_version;
> u16 pci_vendor_id;
> struct acpi_generic_address address;
> u16 max_count;
> u16 min_count;
> u16 period;
> u16 status;
> u16 capability;
>};
># 699 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_wdrt {
> struct acpi_table_header header;
> struct acpi_generic_address control_register;
> struct acpi_generic_address count_register;
> u16 pci_device_id;
> u16 pci_vendor_id;
> u8 pci_bus;
> u8 pci_device;
> u8 pci_function;
> u8 pci_segment;
> u16 max_count;
> u8 units;
>};
># 722 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_wpbt {
> struct acpi_table_header header;
> u32 handoff_size;
> u64 handoff_address;
> u8 layout;
> u8 type;
> u16 arguments_length;
>};
>
>struct acpi_wpbt_unicode {
> u16 *unicode_string;
>};
># 745 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_wsmt {
> struct acpi_table_header header;
> u32 protection_flags;
>};
># 765 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl3.h"
>struct acpi_table_xenv {
> struct acpi_table_header header;
> u64 grant_table_address;
> u64 grant_table_size;
> u32 event_interrupt;
> u8 event_flags;
>};
>
>
>
>#pragma pack()
># 373 "/usr/src/linux-5.14.21-150500.53/include/acpi/actbl.h" 2
># 27 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>typedef u16 acpi_rs_length;
>typedef u32 acpi_rsdesc_size;
># 121 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>#pragma pack(1)
>
>
>
>
>struct acpi_uuid {
> u8 data[16];
>};
>
>struct acpi_vendor_uuid {
> u8 subtype;
> u8 data[16];
>};
>
>
>
>
>struct acpi_resource_irq {
> u8 descriptor_length;
> u8 triggering;
> u8 polarity;
> u8 shareable;
> 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;
>};
>
>struct acpi_resource_fixed_io {
> u16 address;
> u8 address_length;
>};
>
>struct acpi_resource_fixed_dma {
> u16 request_lines;
> u16 channels;
> u8 width;
>};
># 195 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>struct acpi_resource_vendor {
> u16 byte_length;
> u8 byte_data[1];
>};
>
>
>
>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;
>};
>
>struct acpi_resource_memory32 {
> u8 write_protect;
> u32 minimum;
> u32 maximum;
> u32 alignment;
> u32 address_length;
>};
>
>struct acpi_resource_fixed_memory32 {
> u8 write_protect;
> u32 address;
> u32 address_length;
>};
>
>struct acpi_memory_attribute {
> u8 write_protect;
> u8 caching;
> u8 range_type;
> u8 translation;
>};
>
>struct acpi_io_attribute {
> u8 range_type;
> u8 translation;
> u8 translation_type;
> u8 reserved1;
>};
>
>union acpi_resource_attribute {
> struct acpi_memory_attribute mem;
> struct acpi_io_attribute io;
>
>
>
> u8 type_specific;
>};
>
>struct acpi_resource_label {
> u16 string_length;
> char *string_ptr;
>};
>
>struct acpi_resource_source {
> u8 index;
> u16 string_length;
> char *string_ptr;
>};
># 279 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>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_resource_address {
>u8 resource_type; u8 producer_consumer; u8 decode; u8 min_address_fixed; u8 max_address_fixed; union acpi_resource_attribute info;};
>
>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;
>};
>
>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;
>};
>
>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;
>};
>
>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;
>};
>
>struct acpi_resource_extended_irq {
> u8 producer_consumer;
> u8 triggering;
> u8 polarity;
> u8 shareable;
> u8 wake_capable;
> u8 interrupt_count;
> struct acpi_resource_source resource_source;
> u32 interrupts[1];
>};
>
>struct acpi_resource_generic_register {
> u8 space_id;
> u8 bit_width;
> u8 bit_offset;
> u8 access_size;
> u64 address;
>};
>
>struct acpi_resource_gpio {
> u8 revision_id;
> u8 connection_type;
> u8 producer_consumer;
> u8 pin_config;
> u8 shareable;
> 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;
>};
># 398 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>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;};
># 413 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>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;
>};
>
>
>
>
>
>
>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;
>};
># 454 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>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;
>};
># 509 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>struct acpi_resource_csi2_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 local_port_instance;
> u8 phy_type;
>};
>
>struct acpi_resource_pin_function {
> u8 revision_id;
> u8 pin_config;
> u8 shareable;
> u16 function_number;
> u16 pin_table_length;
> u16 vendor_length;
> struct acpi_resource_source resource_source;
> u16 *pin_table;
> u8 *vendor_data;
>};
>
>struct acpi_resource_pin_config {
> u8 revision_id;
> u8 producer_consumer;
> u8 shareable;
> u8 pin_config_type;
> u32 pin_config_value;
> u16 pin_table_length;
> u16 vendor_length;
> struct acpi_resource_source resource_source;
> u16 *pin_table;
> u8 *vendor_data;
>};
># 556 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>struct acpi_resource_pin_group {
> u8 revision_id;
> u8 producer_consumer;
> u16 pin_table_length;
> u16 vendor_length;
> u16 *pin_table;
> struct acpi_resource_label resource_label;
> u8 *vendor_data;
>};
>
>struct acpi_resource_pin_group_function {
> u8 revision_id;
> u8 producer_consumer;
> u8 shareable;
> u16 function_number;
> u16 vendor_length;
> struct acpi_resource_source resource_source;
> struct acpi_resource_label resource_source_label;
> u8 *vendor_data;
>};
>
>struct acpi_resource_pin_group_config {
> u8 revision_id;
> u8 producer_consumer;
> u8 shareable;
> u8 pin_config_type;
> u32 pin_config_value;
> u16 vendor_length;
> struct acpi_resource_source resource_source;
> struct acpi_resource_label resource_source_label;
> u8 *vendor_data;
>};
># 620 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>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_csi2_serialbus csi2_serial_bus;
> struct acpi_resource_common_serialbus common_serial_bus;
> struct acpi_resource_pin_function pin_function;
> struct acpi_resource_pin_config pin_config;
> struct acpi_resource_pin_group pin_group;
> struct acpi_resource_pin_group_function pin_group_function;
> struct acpi_resource_pin_group_config pin_group_config;
>
>
>
> struct acpi_resource_address address;
>};
>
>
>
>struct acpi_resource {
> u32 type;
> u32 length;
> union acpi_resource_data data;
>};
>
>
>
>#pragma pack()
># 677 "/usr/src/linux-5.14.21-150500.53/include/acpi/acrestyp.h"
>struct acpi_pci_routing_table {
> u32 length;
> u32 pin;
> u64 address;
> u32 source_index;
> char source[4];
>};
># 28 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenvex.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenvex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/aclinuxex.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/aclinuxex.h"
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_os_initialize(void);
>
>acpi_status acpi_os_terminate(void);
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *acpi_os_allocate(acpi_size size)
>{
> return kmalloc(size, ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); })? ((( gfp_t)0x20u)|(( gfp_t)0x200u)|(( gfp_t)0x800u)) : ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *acpi_os_allocate_zeroed(acpi_size size)
>{
> return kzalloc(size, ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); })? ((( gfp_t)0x20u)|(( gfp_t)0x200u)|(( gfp_t)0x800u)) : ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_os_free(void *memory)
>{
> kfree(memory);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *acpi_os_acquire_object(struct kmem_cache * cache)
>{
> return kmem_cache_zalloc(cache,
>     ({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); })? ((( gfp_t)0x20u)|(( gfp_t)0x200u)|(( gfp_t)0x800u)) : ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 acpi_os_get_thread_id(void)
>{
> return (u64) (unsigned long)get_current();
>}
># 104 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/aclinuxex.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long acpi_os_acquire_raw_lock(raw_spinlock_t * lockp)
>{
> unsigned long flags;
>
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = _raw_spin_lock_irqsave(lockp); } while (0);
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_os_release_raw_lock(raw_spinlock_t * lockp,
>         unsigned long flags)
>{
> do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _raw_spin_unlock_irqrestore(lockp, flags); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_os_delete_raw_lock(raw_spinlock_t * handle)
>{
> acpi_os_free (handle);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 acpi_os_readable(void *pointer, acpi_size length)
>{
> return (1 == 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) acpi_status acpi_os_initialize_debugger(void)
>{
> return (acpi_status) 0x0000;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_os_terminate_debugger(void)
>{
> return;
>}
># 24 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenvex.h" 2
># 39 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenvex.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acgccex.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/include/acpi/platform/acenvex.h" 2
># 29 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acoutput.h" 1
># 30 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>typedef enum {
> OSL_GLOBAL_LOCK_HANDLER,
> OSL_NOTIFY_HANDLER,
> OSL_GPE_HANDLER,
> OSL_DEBUGGER_MAIN_THREAD,
> OSL_DEBUGGER_EXEC_THREAD,
> OSL_EC_POLL_HANDLER,
> OSL_EC_BURST_HANDLER
>} acpi_execute_type;
># 38 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>struct acpi_signal_fatal_info {
> u32 type;
> u32 code;
> u32 argument;
>};
># 59 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>acpi_physical_address acpi_os_get_root_pointer(void);
>
>
>
>acpi_status
>acpi_os_predefined_override(const struct acpi_predefined_names *init_val,
>       acpi_string *new_val);
>
>
>
>acpi_status
>acpi_os_table_override(struct acpi_table_header *existing_table,
>         struct acpi_table_header **new_table);
>
>
>
>acpi_status
>acpi_os_physical_table_override(struct acpi_table_header *existing_table,
>    acpi_physical_address *new_address,
>    u32 *new_table_length);
># 89 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>void acpi_os_delete_lock(spinlock_t * handle);
>
>
>
>unsigned long acpi_os_acquire_lock(spinlock_t * handle);
>
>
>
>void acpi_os_release_lock(spinlock_t * handle, unsigned long flags);
># 125 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>acpi_status
>acpi_os_create_semaphore(u32 max_units,
>    u32 initial_units, void * * out_handle);
>
>
>
>acpi_status acpi_os_delete_semaphore(void * handle);
>
>
>
>acpi_status
>acpi_os_wait_semaphore(void * handle, u32 units, u16 timeout);
>
>
>
>acpi_status acpi_os_signal_semaphore(void * handle, u32 units);
># 183 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>void *acpi_os_map_memory(acpi_physical_address where, acpi_size length);
>
>
>
>void acpi_os_unmap_memory(void *logical_address, acpi_size size);
>
>
>
>acpi_status
>acpi_os_get_physical_address(void *logical_address,
>        acpi_physical_address *physical_address);
>
>
>
>
>
>
>acpi_status
>acpi_os_create_cache(char *cache_name,
>       u16 object_size,
>       u16 max_depth, struct kmem_cache ** return_cache);
>
>
>
>acpi_status acpi_os_delete_cache(struct kmem_cache * cache);
>
>
>
>acpi_status acpi_os_purge_cache(struct kmem_cache * cache);
>
>
>
>
>
>
>
>acpi_status acpi_os_release_object(struct kmem_cache * cache, void *object);
>
>
>
>
>
>
>acpi_status
>acpi_os_install_interrupt_handler(u32 interrupt_number,
>      acpi_osd_handler service_routine,
>      void *context);
>
>
>
>acpi_status
>acpi_os_remove_interrupt_handler(u32 interrupt_number,
>     acpi_osd_handler service_routine);
># 246 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>acpi_status
>acpi_os_execute(acpi_execute_type type,
>  acpi_osd_exec_callback function, void *context);
>
>
>
>void acpi_os_wait_events_complete(void);
>
>
>
>void acpi_os_sleep(u64 milliseconds);
>
>
>
>void acpi_os_stall(u32 microseconds);
>
>
>
>
>
>
>acpi_status acpi_os_read_port(acpi_io_address address, u32 *value, u32 width);
>
>
>
>acpi_status acpi_os_write_port(acpi_io_address address, u32 value, u32 width);
>
>
>
>
>
>int acpi_os_read_iomem(void *virt_addr, u64 *value, u32 width);
>
>
>acpi_status
>acpi_os_read_memory(acpi_physical_address address, u64 *value, u32 width);
>
>
>
>acpi_status
>acpi_os_write_memory(acpi_physical_address address, u64 value, u32 width);
># 295 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>acpi_status
>acpi_os_read_pci_configuration(struct acpi_pci_id *pci_id,
>          u32 reg, u64 *value, u32 width);
>
>
>
>acpi_status
>acpi_os_write_pci_configuration(struct acpi_pci_id *pci_id,
>    u32 reg, u64 value, u32 width);
># 318 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>u64 acpi_os_get_timer(void);
>
>
>
>acpi_status acpi_os_signal(u32 function, void *info);
>
>
>
>acpi_status acpi_os_enter_sleep(u8 sleep_state, u32 rega_value, u32 regb_value);
>
>
>
>
>
>
>__attribute__ ((__format__ (__printf__, 1, 1 +1)))
>void acpi_os_printf(const char *format, ...);
>
>
>
>void acpi_os_vprintf(const char *format, va_list args);
># 349 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>acpi_status acpi_os_get_line(char *buffer, u32 buffer_length, u32 *bytes_read);
># 361 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpiosxf.h"
>acpi_status acpi_os_wait_command_ready(void);
>
>
>
>acpi_status acpi_os_notify_command_complete(void);
>
>
>
>void
>acpi_os_trace_point(acpi_trace_event_type type,
>      u8 begin, u8 *aml, char *pathname);
># 31 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acconfig.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acbuffer.h" 1
># 32 "/usr/src/linux-5.14.21-150500.53/include/acpi/acbuffer.h"
>struct acpi_fde_info {
> u32 floppy0;
> u32 floppy1;
> u32 floppy2;
> u32 floppy3;
> u32 tape;
>};
>
>
>
>
>
>struct acpi_grt_info {
> u16 year;
> u8 month;
> u8 day;
> u8 hour;
> u8 minute;
> u8 second;
> u8 valid;
> u16 milliseconds;
> u16 timezone;
> u8 daylight;
> u8 reserved[3];
>};
>
>
>
>struct acpi_gtm_info {
> u32 pio_speed0;
> u32 dma_speed0;
> u32 pio_speed1;
> u32 dma_speed1;
> u32 flags;
>};
># 77 "/usr/src/linux-5.14.21-150500.53/include/acpi/acbuffer.h"
>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;
>};
># 21 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h" 2
># 104 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern u8 acpi_gbl_enable_interpreter_slack;
># 113 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern u8 acpi_gbl_auto_serialize_methods;
>
>
>
>
>
>
>extern u8 acpi_gbl_create_osi_method;
>
>
>
>
>
>extern u8 acpi_gbl_use_default_register_widths;
># 136 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern u8 acpi_gbl_enable_table_validation;
>
>
>
>
>extern u8 acpi_gbl_enable_aml_debug_object;
>
>
>
>
>
>
>
>extern u8 acpi_gbl_copy_dsdt_locally;
>
>
>
>
>
>
>
>extern u8 acpi_gbl_do_not_use_xsdt;
># 167 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern u8 acpi_gbl_use32_bit_fadt_addresses;
># 176 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern u8 acpi_gbl_use32_bit_facs_addresses;
>
>
>
>
>
>
>
>extern u8 acpi_gbl_truncate_io_addresses;
>
>
>
>
>
>extern u8 acpi_gbl_disable_auto_repair;
>
>
>
>
>
>extern u8 acpi_gbl_disable_ssdt_table_install;
>
>
>
>
>extern u8 acpi_gbl_runtime_namespace_override;
>
>
>
>
>
>extern u8 acpi_gbl_osi_data;
>
>
>
>
>
>
>extern u8 acpi_gbl_reduced_hardware;
>
>
>
>
>
>
>extern u32 acpi_gbl_max_loop_iterations;
># 231 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern u8 acpi_gbl_ignore_package_resolution_errors;
>
>
>
>
>
>extern u32 acpi_gbl_trace_flags;
>extern const char * acpi_gbl_trace_method_name;
>extern u32 acpi_gbl_trace_dbg_level;
>extern u32 acpi_gbl_trace_dbg_layer;
>
>
>
>
>
>
>extern u32 acpi_dbg_level;
>extern u32 acpi_dbg_layer;
>
>
>
>extern u8 acpi_gbl_display_debug_timer;
># 266 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>extern struct acpi_table_fadt acpi_gbl_FADT;
>extern u32 acpi_current_gpe_count;
>extern u8 acpi_gbl_system_awake_and_running;
># 404 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_initialize_tables(struct acpi_table_desc *initial_storage, u32 initial_table_count, u8 allow_resize);
>
>
>
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_initialize_subsystem(void);
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_enable_subsystem(u32 flags);
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_initialize_objects(u32 flags);
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_terminate(void);
>
>
>
>
>
>acpi_status acpi_enable(void);
>acpi_status acpi_disable(void);
>acpi_status acpi_subsystem_status(void);
>
>acpi_status acpi_get_system_info(struct acpi_buffer *ret_buffer);
>
>
>acpi_status acpi_get_statistics(struct acpi_statistics *stats);
>
>const char *acpi_format_exception(acpi_status exception);
>
>acpi_status acpi_purge_cached_objects(void);
>
>acpi_status acpi_install_interface(acpi_string interface_name);
>
>
>acpi_status acpi_remove_interface(acpi_string interface_name);
>
>acpi_status acpi_update_interfaces(u8 action);
>
>u32 acpi_check_address_range(acpi_adr_space_type space_id, acpi_physical_address address, acpi_size length, u8 warn);
>
>
>
>
>
>acpi_status acpi_decode_pld_buffer(u8 *in_buffer, acpi_size length, struct acpi_pld_info **return_buffer);
># 456 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_install_table(struct acpi_table_header *table);
>
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_install_physical_table(acpi_physical_address address);
>
>
>acpi_status acpi_load_table(struct acpi_table_header *table, u32 *table_idx);
>
>
>
>acpi_status acpi_unload_table(u32 table_index);
>
>
>acpi_status acpi_unload_parent_table(acpi_handle object);
>
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_load_tables(void);
>
>
>
>
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_reallocate_root_table(void);
>
>
>acpi_status __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_find_root_pointer(acpi_physical_address *rsdp_address);
>
>
>acpi_status acpi_get_table_header(acpi_string signature, u32 instance, struct acpi_table_header *out_table_header);
>
>
>
>
>acpi_status acpi_get_table(acpi_string signature, u32 instance, struct acpi_table_header **out_table);
>
>
>
>void acpi_put_table(struct acpi_table_header *table);
>
>acpi_status acpi_get_table_by_index(u32 table_index, struct acpi_table_header **out_table);
>
>
>
>acpi_status acpi_install_table_handler(acpi_table_handler handler, void *context);
>
>
>acpi_status acpi_remove_table_handler(acpi_table_handler handler);
>
>
>
>
>
>
>acpi_status acpi_walk_namespace(acpi_object_type type, acpi_handle start_object, u32 max_depth, acpi_walk_callback descending_callback, acpi_walk_callback ascending_callback, void *context, void **return_value);
># 519 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>acpi_status acpi_get_devices(const char *HID, acpi_walk_callback user_function, void *context, void **return_value);
>
>
>
>
>acpi_status acpi_get_name(acpi_handle object, u32 name_type, struct acpi_buffer *ret_path_ptr);
>
>
>acpi_status acpi_get_handle(acpi_handle parent, acpi_string pathname, acpi_handle *ret_handle);
>
>
>
>acpi_status acpi_attach_data(acpi_handle object, acpi_object_handler handler, void *data);
>
>
>
>acpi_status acpi_detach_data(acpi_handle object, acpi_object_handler handler);
>
>
>acpi_status acpi_get_data(acpi_handle object, acpi_object_handler handler, void **data);
>
>
>
>acpi_status acpi_debug_trace(const char *name, u32 debug_level, u32 debug_layer, u32 flags);
>
>
>
>
>
>
>acpi_status acpi_evaluate_object(acpi_handle object, acpi_string pathname, struct acpi_object_list *parameter_objects, struct acpi_buffer *return_object_buffer);
>
>
>
>
>
>
>acpi_status acpi_evaluate_object_typed(acpi_handle object, acpi_string pathname, struct acpi_object_list *external_params, struct acpi_buffer *return_buffer, acpi_object_type return_type);
># 565 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>acpi_status acpi_get_object_info(acpi_handle object, struct acpi_device_info **return_buffer);
>
>
>
>acpi_status acpi_install_method(u8 *buffer);
>
>acpi_status acpi_get_next_object(acpi_object_type type, acpi_handle parent, acpi_handle child, acpi_handle *out_handle);
>
>
>
>
>
>acpi_status acpi_get_type(acpi_handle object, acpi_object_type *out_type);
>
>
>
>acpi_status acpi_get_parent(acpi_handle object, acpi_handle *out_handle);
>
>
>
>
>
>
>acpi_status acpi_install_initialization_handler (acpi_init_handler handler, u32 function);
>
>
>acpi_status acpi_install_sci_handler(acpi_sci_handler address, void *context);
>
>
>
>acpi_status acpi_remove_sci_handler(acpi_sci_handler address);
>
>
>acpi_status acpi_install_global_event_handler (acpi_gbl_event_handler handler, void *context);
>
>
>
>acpi_status acpi_install_fixed_event_handler(u32 acpi_event, acpi_event_handler handler, void *context);
>
>
>
>
>
>
>acpi_status acpi_remove_fixed_event_handler(u32 acpi_event, acpi_event_handler handler);
>
>
>
>acpi_status acpi_install_gpe_handler(acpi_handle gpe_device, u32 gpe_number, u32 type, acpi_gpe_handler address, void *context);
>
>
>
>
>
>
>
>acpi_status acpi_install_gpe_raw_handler(acpi_handle gpe_device, u32 gpe_number, u32 type, acpi_gpe_handler address, void *context);
>
>
>
>
>
>
>
>acpi_status acpi_remove_gpe_handler(acpi_handle gpe_device, u32 gpe_number, acpi_gpe_handler address);
>
>
>
>
>acpi_status acpi_install_notify_handler(acpi_handle device, u32 handler_type, acpi_notify_handler handler, void *context);
>
>
>
>
>
>acpi_status acpi_remove_notify_handler(acpi_handle device, u32 handler_type, acpi_notify_handler handler);
>
>
>
>
>acpi_status acpi_install_address_space_handler(acpi_handle device, acpi_adr_space_type space_id, acpi_adr_space_handler handler, acpi_adr_space_setup setup, void *context);
># 655 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>acpi_status acpi_remove_address_space_handler(acpi_handle device, acpi_adr_space_type space_id, acpi_adr_space_handler handler);
>
>
>
>
>
>
>acpi_status acpi_install_exception_handler (acpi_exception_handler handler);
>
>
>acpi_status acpi_install_interface_handler (acpi_interface_handler handler);
>
>
>
>
>
>
>acpi_status acpi_acquire_global_lock(u16 timeout, u32 *handle);
>
>
>
>acpi_status acpi_release_global_lock(u32 handle);
>
>
>
>
>
>acpi_status acpi_acquire_mutex(acpi_handle handle, acpi_string pathname, u16 timeout);
>
>
>
>
>acpi_status acpi_release_mutex(acpi_handle handle, acpi_string pathname);
>
>
>
>
>
>
>acpi_status acpi_enable_event(u32 event, u32 flags);
>
>
>acpi_status acpi_disable_event(u32 event, u32 flags);
>
>acpi_status acpi_clear_event(u32 event);
>
>acpi_status acpi_get_event_status(u32 event, acpi_event_status *event_status);
>
>
>
>
>
>
>
>acpi_status acpi_update_all_gpes(void);
>
>acpi_status acpi_enable_gpe(acpi_handle gpe_device, u32 gpe_number);
>
>
>
>acpi_status acpi_disable_gpe(acpi_handle gpe_device, u32 gpe_number);
>
>
>
>acpi_status acpi_clear_gpe(acpi_handle gpe_device, u32 gpe_number);
>
>
>
>acpi_status acpi_set_gpe(acpi_handle gpe_device, u32 gpe_number, u8 action);
>
>
>
>acpi_status acpi_finish_gpe(acpi_handle gpe_device, u32 gpe_number);
>
>
>
>acpi_status acpi_mask_gpe(acpi_handle gpe_device, u32 gpe_number, u8 is_masked);
>
>
>
>acpi_status acpi_mark_gpe_for_wake(acpi_handle gpe_device, u32 gpe_number);
>
>
>
>acpi_status acpi_setup_gpe_for_wake(acpi_handle parent_device, acpi_handle gpe_device, u32 gpe_number);
>
>
>
>
>acpi_status acpi_set_gpe_wake_mask(acpi_handle gpe_device, u32 gpe_number, u8 action);
>
>
>
>acpi_status acpi_get_gpe_status(acpi_handle gpe_device, u32 gpe_number, acpi_event_status *event_status);
>
>
>
>
>u32 acpi_dispatch_gpe(acpi_handle gpe_device, u32 gpe_number);
>acpi_status acpi_disable_all_gpes(void);
>acpi_status acpi_enable_all_runtime_gpes(void);
>acpi_status acpi_enable_all_wakeup_gpes(void);
>u32 acpi_any_gpe_status_set(u32 gpe_skip_number);
>u32 acpi_any_fixed_event_status_set(void);
>
>acpi_status acpi_get_gpe_device(u32 gpe_index, acpi_handle *gpe_device);
>
>
>
>acpi_status acpi_install_gpe_block(acpi_handle gpe_device, struct acpi_generic_address *gpe_block_address, u32 register_count, u32 interrupt_number);
>
>
>
>
>
>
>acpi_status acpi_remove_gpe_block(acpi_handle gpe_device);
>
>
>
>
>
>typedef
>acpi_status (*acpi_walk_resource_callback) (struct acpi_resource * resource,
>         void *context);
>
>acpi_status acpi_get_vendor_resource(acpi_handle device, char *name, struct acpi_vendor_uuid *uuid, struct acpi_buffer *ret_buffer);
>
>
>
>
>
>
>acpi_status acpi_get_current_resources(acpi_handle device, struct acpi_buffer *ret_buffer);
>
>
>
>acpi_status acpi_get_possible_resources(acpi_handle device, struct acpi_buffer *ret_buffer);
>
>
>
>acpi_status acpi_get_event_resources(acpi_handle device_handle, struct acpi_buffer *ret_buffer);
>
>
>
>acpi_status acpi_walk_resource_buffer(struct acpi_buffer *buffer, acpi_walk_resource_callback user_function, void *context);
>
>
>
>
>
>acpi_status acpi_walk_resources(acpi_handle device, char *name, acpi_walk_resource_callback user_function, void *context);
>
>
>
>acpi_status acpi_set_current_resources(acpi_handle device, struct acpi_buffer *in_buffer);
>
>
>
>acpi_status acpi_get_irq_routing_table(acpi_handle device, struct acpi_buffer *ret_buffer);
>
>
>
>acpi_status acpi_resource_to_address64(struct acpi_resource *resource, struct acpi_resource_address64 *out);
>
>
>
>
>
>acpi_status acpi_buffer_to_resource(u8 *aml_buffer, u16 aml_buffer_length, struct acpi_resource **resource_ptr);
># 833 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>acpi_status acpi_reset(void);
>
>acpi_status acpi_read(u64 *value, struct acpi_generic_address *reg);
>
>
>
>acpi_status acpi_write(u64 value, struct acpi_generic_address *reg);
>
>
>
>acpi_status acpi_read_bit_register(u32 register_id, u32 *return_value);
>
>
>
>acpi_status acpi_write_bit_register(u32 register_id, u32 value);
>
>
>
>
>
>
>acpi_status acpi_get_sleep_type_data(u8 sleep_state, u8 *slp_typ_a, u8 *slp_typ_b);
>
>
>
>
>acpi_status acpi_enter_sleep_state_prep(u8 sleep_state);
>
>acpi_status acpi_enter_sleep_state(u8 sleep_state);
>
>acpi_status acpi_enter_sleep_state_s4bios(void);
>
>acpi_status acpi_leave_sleep_state_prep(u8 sleep_state);
>
>acpi_status acpi_leave_sleep_state(u8 sleep_state);
>
>acpi_status acpi_set_firmware_waking_vector (acpi_physical_address physical_address, acpi_physical_address physical_address64);
>
>
>
>
>
>
>acpi_status acpi_get_timer_resolution(u32 *resolution);
>
>acpi_status acpi_get_timer(u32 *ticks);
>
>acpi_status acpi_get_timer_duration(u32 start_ticks, u32 end_ticks, u32 *time_elapsed);
>
>
>
>
>
>
>
>__attribute__ ((__format__ (__printf__, 3, 3 +1))) void acpi_error(const char *module_name, u32 line_number, const char *format, ...);
>
>
>
>
>__attribute__ ((__format__ (__printf__, 4, 4 +1))) void acpi_exception(const char *module_name, u32 line_number, acpi_status status, const char *format, ...);
>
>
>
>
>
>__attribute__ ((__format__ (__printf__, 3, 3 +1))) void acpi_warning(const char *module_name, u32 line_number, const char *format, ...);
>
>
>
>
>__attribute__ ((__format__ (__printf__, 1, 1 +1))) void acpi_info(const char *format, ...);
>
>
>__attribute__ ((__format__ (__printf__, 3, 3 +1))) void acpi_bios_error(const char *module_name, u32 line_number, const char *format, ...);
>
>
>
>
>__attribute__ ((__format__ (__printf__, 4, 4 +1))) void acpi_bios_exception(const char *module_name, u32 line_number, acpi_status status, const char *format, ...);
>
>
>
>
>
>__attribute__ ((__format__ (__printf__, 3, 3 +1))) void acpi_bios_warning(const char *module_name, u32 line_number, const char *format, ...);
># 927 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__ ((__format__ (__printf__, 6, 6 +1))) void acpi_debug_print(u32 requested_debug_level, u32 line_number, const char *function_name, const char *module_name, u32 component_id, const char *format, ...) {return;}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__ ((__format__ (__printf__, 6, 6 +1))) void acpi_debug_print_raw(u32 requested_debug_level, u32 line_number, const char *function_name, const char *module_name, u32 component_id, const char *format, ...) {return;}
># 944 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpixf.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_trace_point(acpi_trace_event_type type, u8 begin, u8 *aml, char *pathname) {return;}
>
>
>
>
>acpi_status acpi_initialize_debugger(void);
>
>void acpi_terminate_debugger(void);
>
>
>
>
>acpi_status acpi_get_data_full(acpi_handle object, acpi_object_handler handler, void **data, void (*callback)(void *));
>
>
>
>
>
>void acpi_run_debugger(char *batch_buffer);
>
>void acpi_set_debugger_thread_id(u64 thread_id);
># 32 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 2
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>struct acpi_handle_list {
> u32 count;
> acpi_handle handles[10];
>};
>
>
>acpi_status
>acpi_extract_package(union acpi_object *package,
>       struct acpi_buffer *format, struct acpi_buffer *buffer);
>acpi_status
>acpi_evaluate_integer(acpi_handle handle,
>        acpi_string pathname,
>        struct acpi_object_list *arguments, unsigned long long *data);
>acpi_status
>acpi_evaluate_reference(acpi_handle handle,
>   acpi_string pathname,
>   struct acpi_object_list *arguments,
>   struct acpi_handle_list *list);
>acpi_status
>acpi_evaluate_ost(acpi_handle handle, u32 source_event, u32 status_code,
>    struct acpi_buffer *status_buf);
>
>acpi_status
>acpi_get_physical_device_location(acpi_handle handle, struct acpi_pld_info **pld);
>
>bool acpi_has_method(acpi_handle handle, char *name);
>acpi_status acpi_execute_simple_method(acpi_handle handle, char *method,
>           u64 arg);
>acpi_status acpi_evaluate_ej0(acpi_handle handle);
>acpi_status acpi_evaluate_lck(acpi_handle handle, int lock);
>acpi_status acpi_evaluate_reg(acpi_handle handle, u8 space_id, u32 function);
>bool acpi_ata_match(acpi_handle handle);
>bool acpi_bay_match(acpi_handle handle);
>bool acpi_dock_match(acpi_handle handle);
>
>bool acpi_check_dsm(acpi_handle handle, const guid_t *guid, u64 rev, u64 funcs);
>union acpi_object *acpi_evaluate_dsm(acpi_handle handle, const guid_t *guid,
>   u64 rev, u64 func, union acpi_object *argv4);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) union acpi_object *
>acpi_evaluate_dsm_typed(acpi_handle handle, const guid_t *guid, u64 rev,
>   u64 func, union acpi_object *argv4,
>   acpi_object_type type)
>{
> union acpi_object *obj;
>
> obj = acpi_evaluate_dsm(handle, guid, rev, func, argv4);
> if (obj && obj->type != type) {
>  acpi_os_free (obj);
>  obj = ((void *)0);
> }
>
> return obj;
>}
># 79 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>bool acpi_dev_found(const char *hid);
>bool acpi_dev_present(const char *hid, const char *uid, s64 hrv);
>bool acpi_reduced_hardware(void);
>
>
>
>struct proc_dir_entry;
>
>
>extern struct proc_dir_entry *acpi_root_dir;
>
>enum acpi_bus_device_type {
> ACPI_BUS_TYPE_DEVICE = 0,
> ACPI_BUS_TYPE_POWER,
> ACPI_BUS_TYPE_PROCESSOR,
> ACPI_BUS_TYPE_THERMAL,
> ACPI_BUS_TYPE_POWER_BUTTON,
> ACPI_BUS_TYPE_SLEEP_BUTTON,
> ACPI_BUS_TYPE_ECDT_EC,
> ACPI_BUS_DEVICE_TYPE_COUNT
>};
>
>struct acpi_driver;
>struct acpi_device;
>
>
>
>
>
>
>struct acpi_hotplug_profile {
> struct kobject kobj;
> int (*scan_dependent)(struct acpi_device *adev);
> void (*notify_online)(struct acpi_device *adev);
> bool enabled:1;
> bool demand_offline:1;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct acpi_hotplug_profile *to_acpi_hotplug_profile(
>      struct kobject *kobj)
>{
> return ({ void *__mptr = (void *)(kobj); do { extern void __compiletime_assert_311(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(kobj)), typeof(((struct acpi_hotplug_profile *)0)->kobj)) && !__builtin_types_compatible_p(typeof(*(kobj)), typeof(void))))) __compiletime_assert_311(); } while (0); ((struct acpi_hotplug_profile *)(__mptr - __builtin_offsetof(struct acpi_hotplug_profile, kobj))); });
>}
>
>struct acpi_scan_handler {
> const struct acpi_device_id *ids;
> struct list_head list_node;
> bool (*match)(const char *idstr, const struct acpi_device_id **matchid);
> int (*attach)(struct acpi_device *dev, const struct acpi_device_id *id);
> void (*detach)(struct acpi_device *dev);
> void (*bind)(struct device *phys_dev);
> void (*unbind)(struct device *phys_dev);
> struct acpi_hotplug_profile hotplug;
>};
>
>
>
>
>
>
>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 *);
>};
>
>
>
>
>
>
>typedef int (*acpi_op_add) (struct acpi_device * device);
>typedef int (*acpi_op_remove) (struct acpi_device * device);
>typedef void (*acpi_op_notify) (struct acpi_device * device, u32 event);
>
>struct acpi_device_ops {
> acpi_op_add add;
> acpi_op_remove remove;
> acpi_op_notify notify;
>};
>
>
>
>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 drv;
> struct module *owner;
>};
># 180 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>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 enumeration_by_parent:1;
> u32 honor_deps:1;
> u32 reserved:18;
>};
>
>
>
>struct acpi_device_dir {
> struct proc_dir_entry *entry;
>};
>
>
>
>
>
>typedef char acpi_bus_id[8];
>typedef u64 acpi_bus_address;
>typedef char acpi_device_name[40];
>typedef char acpi_device_class[20];
>
>struct acpi_hardware_id {
> struct list_head list;
> const char *id;
>};
>
>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;
> int instance_no;
> 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;
>};
>
>
>
>const char *acpi_device_hid(struct acpi_device *device);
>
>
>
>
>
>
>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];
> u8 state_for_enumeration;
>};
>
>struct acpi_dep_data {
> struct list_head node;
> acpi_handle supplier;
> acpi_handle consumer;
> bool honor_dep;
>};
>
>
>
>struct acpi_device_perf_flags {
> u8 reserved:8;
>};
>
>struct acpi_device_perf_state {
> struct {
>  u8 valid:1;
>  u8 reserved:7;
> } flags;
> u8 power;
> u8 performance;
> int latency;
>};
>
>struct acpi_device_perf {
> int state;
> struct acpi_device_perf_flags flags;
> int state_count;
> struct acpi_device_perf_state *states;
>};
>
>
>struct acpi_device_wakeup_flags {
> u8 valid:1;
> u8 notifier_present:1;
>};
>
>struct acpi_device_wakeup_context {
> void (*func)(struct acpi_device_wakeup_context *context);
> struct device *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;
> int enable_count;
>};
>
>struct acpi_device_physical_node {
> unsigned int node_id;
> struct list_head node;
> struct device *dev;
> bool put_online:1;
>};
>
>struct acpi_device_properties {
> const guid_t *guid;
> union acpi_object *properties;
> struct list_head list;
> void **bufs;
>};
>
>
>struct acpi_device_data {
> const union acpi_object *pointer;
> struct list_head properties;
> const union acpi_object *of_compatible;
> struct list_head subnodes;
>};
>
>struct acpi_gpio_mapping;
>
>
>struct acpi_device {
> u32 pld_crc;
> int device_type;
> acpi_handle handle;
> struct fwnode_handle fwnode;
> struct acpi_device *parent;
> 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;
> const struct acpi_gpio_mapping *driver_gpios;
> void *driver_data;
> struct device dev;
> unsigned int physical_node_count;
> unsigned int dep_unmet;
> struct list_head physical_node_list;
> struct mutex physical_node_lock;
> void (*remove)(struct acpi_device *);
>};
>
>
>struct acpi_data_node {
> const char *name;
> acpi_handle handle;
> struct fwnode_handle fwnode;
> struct fwnode_handle *parent;
> struct acpi_device_data data;
> struct list_head sibling;
> struct kobject kobj;
> struct completion kobj_done;
>};
>
>extern const struct fwnode_operations acpi_device_fwnode_ops;
>extern const struct fwnode_operations acpi_data_fwnode_ops;
>extern const struct fwnode_operations acpi_static_fwnode_ops;
>
>bool is_acpi_device_node(const struct fwnode_handle *fwnode);
>bool is_acpi_data_node(const struct fwnode_handle *fwnode);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_acpi_node(const struct fwnode_handle *fwnode)
>{
> return (is_acpi_device_node(fwnode) || is_acpi_data_node(fwnode));
>}
># 435 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_acpi_static_node(const struct fwnode_handle *fwnode)
>{
> return !IS_ERR_OR_NULL(fwnode) &&
>  fwnode->ops == &acpi_static_fwnode_ops;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_data_node_match(const struct fwnode_handle *fwnode,
>     const char *name)
>{
> return is_acpi_data_node(fwnode) ?
>  (!strcmp(({ typeof(fwnode) __to_acpi_data_node_fwnode = fwnode; is_acpi_data_node(__to_acpi_data_node_fwnode) ? ({ void *__mptr = (void *)(__to_acpi_data_node_fwnode); do { extern void __compiletime_assert_312(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(__to_acpi_data_node_fwnode)), typeof(((struct acpi_data_node *)0)->fwnode)) && !__builtin_types_compatible_p(typeof(*(__to_acpi_data_node_fwnode)), typeof(void))))) __compiletime_assert_312(); } while (0); ((struct acpi_data_node *)(__mptr - __builtin_offsetof(struct acpi_data_node, fwnode))); }) : ((void *)0); })->name, name)) : false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fwnode_handle *acpi_fwnode_handle(struct acpi_device *adev)
>{
> return &adev->fwnode;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *acpi_driver_data(struct acpi_device *d)
>{
> return d->driver_data;
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_set_device_status(struct acpi_device *adev, u32 sta)
>{
> *((u32 *)&adev->status) = sta;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_set_hp_context(struct acpi_device *adev,
>           struct acpi_hotplug_context *hp)
>{
> hp->self = adev;
> adev->hp = hp;
>}
>
>void acpi_initialize_hp_context(struct acpi_device *adev,
>    struct acpi_hotplug_context *hp,
>    int (*notify)(struct acpi_device *, u32),
>    void (*uevent)(struct acpi_device *, u32));
>
>
>extern struct bus_type acpi_bus_type;
>
>int acpi_bus_for_each_dev(int (*fn)(struct device *, void *), void *data);
>int acpi_dev_for_each_child(struct acpi_device *adev,
>       int (*fn)(struct acpi_device *, void *), void *data);
>int acpi_dev_for_each_child_reverse(struct acpi_device *adev,
>        int (*fn)(struct acpi_device *, void *),
>        void *data);
>
>
>
>
>
>
>struct acpi_bus_event {
> struct list_head node;
> acpi_device_class device_class;
> acpi_bus_id bus_id;
> u32 type;
> u32 data;
>};
>
>extern struct kobject *acpi_kobj;
>extern int acpi_bus_generate_netlink_event(const char*, const char*, u8, int);
>void acpi_bus_private_data_handler(acpi_handle, void *);
>int acpi_bus_get_private_data(acpi_handle, void **);
>int acpi_bus_attach_private_data(acpi_handle, void *);
>void acpi_bus_detach_private_data(acpi_handle);
>extern int acpi_notifier_call_chain(struct acpi_device *, u32, u32);
>extern int register_acpi_notifier(struct notifier_block *);
>extern int unregister_acpi_notifier(struct notifier_block *);
>
>
>
>
>
>int acpi_bus_get_device(acpi_handle handle, struct acpi_device **device);
>struct acpi_device *acpi_fetch_acpi_dev(acpi_handle handle);
>acpi_status acpi_bus_get_status_handle(acpi_handle handle,
>           unsigned long long *sta);
>int acpi_bus_get_status(struct acpi_device *device);
>
>int acpi_bus_set_power(acpi_handle handle, int state);
>const char *acpi_power_state_string(int state);
>int acpi_device_set_power(struct acpi_device *device, int state);
>int acpi_bus_init_power(struct acpi_device *device);
>int acpi_device_fix_up_power(struct acpi_device *device);
>void acpi_device_fix_up_power_extended(struct acpi_device *adev);
>int acpi_bus_update_power(acpi_handle handle, int *state_p);
>int acpi_device_update_power(struct acpi_device *device, int *state_p);
>bool acpi_bus_power_manageable(acpi_handle handle);
>void acpi_dev_power_up_children_with_adr(struct acpi_device *adev);
>int acpi_device_power_add_dependent(struct acpi_device *adev,
>        struct device *dev);
>void acpi_device_power_remove_dependent(struct acpi_device *adev,
>     struct device *dev);
>
>
>bool acpi_bus_can_wakeup(acpi_handle handle);
>
>
>
>
>void acpi_scan_lock_acquire(void);
>void acpi_scan_lock_release(void);
>void acpi_lock_hp_context(void);
>void acpi_unlock_hp_context(void);
>int acpi_scan_add_handler(struct acpi_scan_handler *handler);
>int acpi_bus_register_driver(struct acpi_driver *driver);
>void acpi_bus_unregister_driver(struct acpi_driver *driver);
>int acpi_bus_scan(acpi_handle handle);
>void acpi_bus_trim(struct acpi_device *start);
>acpi_status acpi_bus_get_ejd(acpi_handle handle, acpi_handle * ejd);
>int acpi_match_device_ids(struct acpi_device *device,
>     const struct acpi_device_id *ids);
>void acpi_set_modalias(struct acpi_device *adev, const char *default_id,
>         char *modalias, size_t len);
>int acpi_create_dir(struct acpi_device *);
>void acpi_remove_dir(struct acpi_device *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_device_enumerated(struct acpi_device *adev)
>{
> return adev && adev->flags.initialized && adev->flags.visited;
>}
># 579 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>struct acpi_bus_type {
> struct list_head list;
> const char *name;
> bool (*match)(struct device *dev);
> struct acpi_device * (*find_companion)(struct device *);
> void (*setup)(struct device *);
>};
>int register_acpi_bus_type(struct acpi_bus_type *);
>int unregister_acpi_bus_type(struct acpi_bus_type *);
>int acpi_bind_one(struct device *dev, struct acpi_device *adev);
>int acpi_unbind_one(struct device *dev);
>
>enum acpi_bridge_type {
> ACPI_BRIDGE_TYPE_PCIE = 1,
> ACPI_BRIDGE_TYPE_CXL,
>};
>
>struct acpi_pci_root {
> struct acpi_device * device;
> struct pci_bus *bus;
> u16 segment;
> int bridge_type;
> struct resource secondary;
>
> u32 osc_support_set;
> u32 osc_control_set;
> u32 osc_ext_support_set;
> u32 osc_ext_control_set;
> phys_addr_t mcfg_addr;
>};
>
>
>
>bool acpi_dma_supported(const struct acpi_device *adev);
>enum dev_dma_attr acpi_get_dma_attr(struct acpi_device *adev);
>int acpi_iommu_fwspec_init(struct device *dev, u32 id,
>      struct fwnode_handle *fwnode,
>      const struct iommu_ops *ops);
>int acpi_dma_get_range(struct device *dev, u64 *dma_addr, u64 *offset,
>         u64 *size);
>int acpi_dma_configure_id(struct device *dev, enum dev_dma_attr attr,
>      const u32 *input_id);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_dma_configure(struct device *dev,
>         enum dev_dma_attr attr)
>{
> return acpi_dma_configure_id(dev, attr, ((void *)0));
>}
>struct acpi_device *acpi_find_child_device(struct acpi_device *parent,
>        u64 address, bool check_children);
>struct acpi_device *acpi_find_child_by_adr(struct acpi_device *adev,
>        acpi_bus_address adr);
>int acpi_is_root_bridge(acpi_handle);
>struct acpi_pci_root *acpi_pci_find_root(acpi_handle handle);
>
>int acpi_enable_wakeup_device_power(struct acpi_device *dev, int state);
>int acpi_disable_wakeup_device_power(struct acpi_device *dev);
>
>
>bool acpi_device_override_status(struct acpi_device *adev, unsigned long long *status);
>bool acpi_quirk_skip_acpi_ac_and_battery(void);
># 655 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_quirk_skip_i2c_client_enumeration(struct acpi_device *adev)
>{
> return false;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>acpi_quirk_skip_serdev_enumeration(struct device *controller_parent, bool *skip)
>{
> *skip = false;
> return 0;
>}
>
>
>
>void acpi_pm_wakeup_event(struct device *dev);
>acpi_status acpi_add_pm_notifier(struct acpi_device *adev, struct device *dev,
>   void (*func)(struct acpi_device_wakeup_context *context));
>acpi_status acpi_remove_pm_notifier(struct acpi_device *adev);
>bool acpi_pm_device_can_wakeup(struct device *dev);
>int acpi_pm_device_sleep_state(struct device *, int *, int);
>int acpi_pm_set_device_wakeup(struct device *dev, bool enable);
># 708 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>bool acpi_sleep_state_supported(u8 sleep_state);
>
>
>
>
>
>u32 acpi_target_system_state(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_device_power_manageable(struct acpi_device *adev)
>{
> return adev->flags.power_manageable;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_device_can_wakeup(struct acpi_device *adev)
>{
> return adev->wakeup.flags.valid;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_device_can_poweroff(struct acpi_device *adev)
>{
> return adev->power.states[(u8) 4].flags.valid ||
>  ((acpi_gbl_FADT.header.revision < 6) &&
>  adev->power.states[(u8) 3].flags.explicit_set);
>}
>
>bool acpi_dev_hid_uid_match(struct acpi_device *adev, const char *hid2, const char *uid2);
>
>void acpi_dev_clear_dependencies(struct acpi_device *supplier);
>bool acpi_dev_ready_for_enumeration(const struct acpi_device *device);
>struct acpi_device *acpi_dev_get_first_consumer_dev(struct acpi_device *supplier);
>struct acpi_device *
>acpi_dev_get_next_match_dev(struct acpi_device *adev, const char *hid, const char *uid, s64 hrv);
>struct acpi_device *
>acpi_dev_get_first_match_dev(const char *hid, const char *uid, s64 hrv);
># 760 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_bus.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct acpi_device *acpi_dev_get(struct acpi_device *adev)
>{
> return adev ? ({ void *__mptr = (void *)(get_device(&adev->dev)); do { extern void __compiletime_assert_313(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(get_device(&adev->dev))), typeof(((struct acpi_device *)0)->dev)) && !__builtin_types_compatible_p(typeof(*(get_device(&adev->dev))), typeof(void))))) __compiletime_assert_313(); } while (0); ((struct acpi_device *)(__mptr - __builtin_offsetof(struct acpi_device, dev))); }) : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_dev_put(struct acpi_device *adev)
>{
> if (adev)
>  put_device(&adev->dev);
>}
>
>struct acpi_device *acpi_bus_get_acpi_device(acpi_handle handle);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_bus_put_acpi_device(struct acpi_device *adev)
>{
> acpi_dev_put(adev);
>}
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_drivers.h" 1
># 50 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_drivers.h"
>int acpi_irq_penalty_init(void);
>int acpi_pci_link_allocate_irq(acpi_handle handle, int index, int *triggering,
>          int *polarity, char **name);
>int acpi_pci_link_free_irq(acpi_handle handle);
>
>
>
>struct pci_bus;
>
>
>struct pci_dev *acpi_get_pci_dev(acpi_handle);
># 70 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_drivers.h"
>struct pci_bus *pci_acpi_scan_root(struct acpi_pci_root *root);
>
>
>void pci_acpi_crs_quirks(void);
># 83 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_drivers.h"
>extern int is_dock_device(struct acpi_device *adev);
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_numa.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_numa.h"
>extern int pxm_to_node(int);
>extern int node_to_pxm(int);
>extern int acpi_map_pxm_to_node(int);
>extern unsigned char acpi_srat_revision;
>extern void disable_srat(void);
>
>extern void bad_srat(void);
>extern int srat_disabled(void);
># 39 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_numa.h"
>extern void disable_hmat(void);
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_io.h" 1
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/pdc_intel.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/numa.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/numa.h"
>extern int numa_off;
># 32 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/numa.h"
>extern s16 __apicid_to_node[32768];
>extern nodemask_t numa_nodes_parsed __attribute__((__section__(".init.data")));
>
>extern int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) numa_add_memblk(int nodeid, u64 start, u64 end);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) numa_set_distance(int from, int to, int distance);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_apicid_to_node(int apicid, s16 node)
>{
> __apicid_to_node[apicid] = node;
>}
>
>extern int numa_cpu_node(int cpu);
># 61 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/numa.h"
>extern void numa_set_node(int cpu, int node);
>extern void numa_clear_node(int cpu);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) init_cpu_to_node(void);
>extern void numa_add_cpu(int cpu);
>extern void numa_remove_cpu(int cpu);
>extern void init_gi_nodes(void);
># 83 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/numa.h"
>int numa_emu_cmdline(char *str);
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h"
>extern int acpi_lapic;
>extern int acpi_ioapic;
>extern int acpi_noirq;
>extern int acpi_strict;
>extern int acpi_disabled;
>extern int acpi_pci_disabled;
>extern int acpi_skip_timer_override;
>extern int acpi_use_timer_override;
>extern int acpi_fix_pin2_polarity;
>extern int acpi_disable_cmcff;
>
>extern u8 acpi_sci_flags;
>extern u32 acpi_sci_override_gsi;
>void acpi_pic_sci_set_trigger(unsigned int, u16);
>
>struct device;
>
>extern int (*__acpi_register_gsi)(struct device *dev, u32 gsi,
>      int trigger, int polarity);
>extern void (*__acpi_unregister_gsi)(u32 gsi);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void disable_acpi(void)
>{
> acpi_disabled = 1;
> acpi_pci_disabled = 1;
> acpi_noirq = 1;
>}
>
>extern int acpi_gsi_to_irq(u32 gsi, unsigned int *irq);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_noirq_set(void) { acpi_noirq = 1; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_disable_pci(void)
>{
> acpi_pci_disabled = 1;
> acpi_noirq_set();
>}
>
>
>extern int (*acpi_suspend_lowlevel)(void);
>
>
>unsigned long acpi_get_wakeup_address(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int acpi_processor_cstate_check(unsigned int max_cstate)
>{
>
>
>
>
>
>
> if (boot_cpu_data.x86 == 0x0F &&
>     boot_cpu_data.x86_vendor == 2 &&
>     boot_cpu_data.x86_model <= 0x05 &&
>     boot_cpu_data.x86_stepping < 0x0A)
>  return 1;
> else if ((__builtin_constant_p((22*32 + (4))) && ( ((((22*32 + (4)))>>5)==(0) && (1UL<<(((22*32 + (4)))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || ((((22*32 + (4)))>>5)==(1) && (1UL<<(((22*32 + (4)))&31) & ((1<<(( 1*32+29) & 31))|0) )) || ((((22*32 + (4)))>>5)==(2) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(3) && (1UL<<(((22*32 + (4)))&31) & ((1<<(( 3*32+20) & 31))) )) || ((((22*32 + (4)))>>5)==(4) && (1UL<<(((22*32 + (4)))&31) & (0) )) || ((((22*32 + (4)))>>5)==(5) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(6) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(7) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(8) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(9) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(10) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(11) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(12) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(13) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(14) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(15) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(16) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(17) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(18) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((((22*32 + (4)))>>5)==(19) && (1UL<<(((22*32 + (4)))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit((22*32 + (4)), (unsigned long *)((&boot_cpu_data)->x86_capability))))
>  return 1;
> else
>  return max_cstate;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_has_acpi_pdc(void)
>{
> struct cpuinfo_x86 *c = &(*({ do { const void *__vpp_verify = (typeof((&(cpu_info)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(cpu_info)))) *)((&(cpu_info))))); (typeof((typeof(*((&(cpu_info)))) *)((&(cpu_info))))) (__ptr + (((__per_cpu_offset[(0)])))); }); }));
> return (c->x86_vendor == 0 ||
>  c->x86_vendor == 5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_acpi_set_pdc_bits(u32 *buf)
>{
> struct cpuinfo_x86 *c = &(*({ do { const void *__vpp_verify = (typeof((&(cpu_info)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(cpu_info)))) *)((&(cpu_info))))); (typeof((typeof(*((&(cpu_info)))) *)((&(cpu_info))))) (__ptr + (((__per_cpu_offset[(0)])))); }); }));
>
> buf[2] |= ((0x0010) | (0x0008) | (0x0002) | (0x0100) | (0x0200));
>
> if ((__builtin_constant_p(( 4*32+ 7)) && ( (((( 4*32+ 7))>>5)==(0) && (1UL<<((( 4*32+ 7))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 4*32+ 7))>>5)==(1) && (1UL<<((( 4*32+ 7))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 4*32+ 7))>>5)==(2) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(3) && (1UL<<((( 4*32+ 7))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 4*32+ 7))>>5)==(4) && (1UL<<((( 4*32+ 7))&31) & (0) )) || (((( 4*32+ 7))>>5)==(5) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(6) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(7) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(8) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(9) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(10) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(11) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(12) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(13) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(14) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(15) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(16) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(17) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(18) && (1UL<<((( 4*32+ 7))&31) & 0 )) || (((( 4*32+ 7))>>5)==(19) && (1UL<<((( 4*32+ 7))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 4*32+ 7), (unsigned long *)((c)->x86_capability))))
>  buf[2] |= ((0x0008) | (0x0002) | (0x0020) | (0x0800) | (0x0001));
>
> if ((__builtin_constant_p(( 0*32+22)) && ( (((( 0*32+22))>>5)==(0) && (1UL<<((( 0*32+22))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 0*32+22))>>5)==(1) && (1UL<<((( 0*32+22))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 0*32+22))>>5)==(2) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(3) && (1UL<<((( 0*32+22))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 0*32+22))>>5)==(4) && (1UL<<((( 0*32+22))&31) & (0) )) || (((( 0*32+22))>>5)==(5) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(6) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(7) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(8) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(9) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(10) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(11) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(12) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(13) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(14) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(15) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(16) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(17) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(18) && (1UL<<((( 0*32+22))&31) & 0 )) || (((( 0*32+22))>>5)==(19) && (1UL<<((( 0*32+22))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 0*32+22), (unsigned long *)((c)->x86_capability))))
>  buf[2] |= (0x0004);
>
>
>
>
> if (!(__builtin_constant_p(( 4*32+ 3)) && ( (((( 4*32+ 3))>>5)==(0) && (1UL<<((( 4*32+ 3))&31) & ((1<<(( 0*32+ 0) & 31))|0|(1<<(( 0*32+ 5) & 31))|(1<<(( 0*32+ 6) & 31))| (1<<(( 0*32+ 8) & 31))|0|(1<<(( 0*32+24) & 31))|(1<<(( 0*32+15) & 31))| (1<<(( 0*32+25) & 31))|(1<<(( 0*32+26) & 31))) )) || (((( 4*32+ 3))>>5)==(1) && (1UL<<((( 4*32+ 3))&31) & ((1<<(( 1*32+29) & 31))|0) )) || (((( 4*32+ 3))>>5)==(2) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(3) && (1UL<<((( 4*32+ 3))&31) & ((1<<(( 3*32+20) & 31))) )) || (((( 4*32+ 3))>>5)==(4) && (1UL<<((( 4*32+ 3))&31) & (0) )) || (((( 4*32+ 3))>>5)==(5) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(6) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(7) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(8) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(9) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(10) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(11) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(12) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(13) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(14) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(15) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(16) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(17) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(18) && (1UL<<((( 4*32+ 3))&31) & 0 )) || (((( 4*32+ 3))>>5)==(19) && (1UL<<((( 4*32+ 3))&31) & 0 )) || ((int)(sizeof(struct { int:(-!!(22 != 22)); }))) || ((int)(sizeof(struct { int:(-!!(22 != 22)); })))) ? 1 : test_bit(( 4*32+ 3), (unsigned long *)((c)->x86_capability))))
>  buf[2] &= ~((0x0200));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_has_cpu_in_madt(void)
>{
> return !!acpi_lapic;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_arch_set_root_pointer(u64 addr)
>{
> x86_init.acpi.set_root_pointer(addr);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 acpi_arch_get_root_pointer(void)
>{
> return x86_init.acpi.get_root_pointer();
>}
>
>void acpi_generic_reduced_hw_init(void);
>
>void x86_default_set_root_pointer(u64 addr);
>u64 x86_default_get_root_pointer(void);
># 159 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h"
>extern int x86_acpi_numa_init(void);
>
>
>struct cper_ia_proc_ctx;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) pgprot_t arch_apei_get_mem_attribute(phys_addr_t addr)
>{
># 180 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/acpi.h"
> return ((pgprot_t) { ((((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)|(((pteval_t)(1)) << 63)|(((pteval_t)(1)) << 6)| 0|(((pteval_t)(1)) << 8)) | 0) & __default_kernel_pte_mask) } );
>}
>
>int arch_apei_report_x86_error(struct cper_ia_proc_ctx *ctx_info,
>          u64 lapic_id);
># 8 "/usr/src/linux-5.14.21-150500.53/include/acpi/acpi_io.h" 2
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *acpi_os_ioremap(acpi_physical_address phys,
>         acpi_size size)
>{
>       return ioremap_cache(phys, size);
>}
>
>
>extern bool acpi_permanent_mmap;
>
>void __attribute__((__section__(".ref.text"))) __attribute__((__noinline__))
>*acpi_os_map_iomem(acpi_physical_address phys, acpi_size size);
>void __attribute__((__section__(".ref.text"))) __attribute__((__noinline__)) acpi_os_unmap_iomem(void *virt, acpi_size size);
>void *acpi_os_get_iomem(acpi_physical_address phys, unsigned int size);
>
>void *acpi_os_map_generic_address(struct acpi_generic_address *addr);
>void acpi_os_unmap_generic_address(struct acpi_generic_address *addr);
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h" 2
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) acpi_handle acpi_device_handle(struct acpi_device *adev)
>{
> return adev ? adev->handle : ((void *)0);
>}
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct fwnode_handle *acpi_alloc_fwnode_static(void)
>{
> struct fwnode_handle *fwnode;
>
> fwnode = kzalloc(sizeof(struct fwnode_handle), ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
> if (!fwnode)
>  return ((void *)0);
>
> fwnode_init(fwnode, &acpi_static_fwnode_ops);
>
> return fwnode;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_free_fwnode_static(struct fwnode_handle *fwnode)
>{
> if (({ int __ret_warn_on = !!(!is_acpi_static_node(fwnode)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"), "i" (65), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("314" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "314" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }))
>  return;
>
> kfree(fwnode);
>}
># 84 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool has_acpi_companion(struct device *dev)
>{
> return is_acpi_device_node(dev->fwnode);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_preset_companion(struct device *dev,
>      struct acpi_device *parent, u64 addr)
>{
> set_primary_fwnode(dev, (acpi_find_child_device(parent, addr, false)) ? acpi_fwnode_handle(acpi_find_child_device(parent, addr, false)) : ((void *)0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const char *acpi_dev_name(struct acpi_device *adev)
>{
> return dev_name(&adev->dev);
>}
>
>struct device *acpi_get_first_physical_node(struct acpi_device *adev);
>
>enum acpi_irq_model_id {
> ACPI_IRQ_MODEL_PIC = 0,
> ACPI_IRQ_MODEL_IOAPIC,
> ACPI_IRQ_MODEL_IOSAPIC,
> ACPI_IRQ_MODEL_PLATFORM,
> ACPI_IRQ_MODEL_GIC,
> ACPI_IRQ_MODEL_COUNT
>};
>
>extern enum acpi_irq_model_id acpi_irq_model;
>
>enum acpi_interrupt_id {
> ACPI_INTERRUPT_PMI = 1,
> ACPI_INTERRUPT_INIT,
> ACPI_INTERRUPT_CPEI,
> ACPI_INTERRUPT_COUNT
>};
>
>
>
>enum acpi_address_range_id {
> ACPI_ADDRESS_RANGE_MEMORY = 1,
> ACPI_ADDRESS_RANGE_RESERVED = 2,
> ACPI_ADDRESS_RANGE_ACPI = 3,
> ACPI_ADDRESS_RANGE_NVS = 4,
> ACPI_ADDRESS_RANGE_COUNT
>};
>
>
>
>union acpi_subtable_headers {
> struct acpi_subtable_header common;
> struct acpi_hmat_structure hmat;
> struct acpi_prmt_module_header prmt;
> struct acpi_cedt_header cedt;
>};
>
>typedef int (*acpi_tbl_table_handler)(struct acpi_table_header *table);
>
>typedef int (*acpi_tbl_entry_handler)(union acpi_subtable_headers *header,
>          const unsigned long end);
>
>typedef int (*acpi_tbl_entry_handler_arg)(union acpi_subtable_headers *header,
>       void *arg, const unsigned long end);
>
>
>
>struct acpi_debugger_ops {
> int (*create_thread)(acpi_osd_exec_callback function, void *context);
> ssize_t (*write_log)(const char *msg);
> ssize_t (*read_cmd)(char *buffer, size_t length);
> int (*wait_command_ready)(bool single_step, char *buffer, size_t length);
> int (*notify_command_complete)(void);
>};
>
>struct acpi_debugger {
> const struct acpi_debugger_ops *ops;
> struct module *owner;
> struct mutex lock;
>};
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_debugger_init(void)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_register_debugger(struct module *owner,
>      const struct acpi_debugger_ops *ops)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_unregister_debugger(const struct acpi_debugger_ops *ops)
>{
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_debugger_create_thread(acpi_osd_exec_callback function,
>           void *context)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_debugger_write_log(const char *msg)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_debugger_read_cmd(char *buffer, u32 buffer_length)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_debugger_wait_command_ready(void)
>{
> return -19;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_debugger_notify_command_complete(void)
>{
> return -19;
>}
>
>
>
>
>
>
>struct acpi_subtable_proc {
> int id;
> acpi_tbl_entry_handler handler;
> acpi_tbl_entry_handler_arg handler_arg;
> void *arg;
> int count;
>};
>
>void *__acpi_map_table(unsigned long phys, unsigned long size);
>void __acpi_unmap_table(void *map, unsigned long size);
>int early_acpi_boot_init(void);
>int acpi_boot_init (void);
>void acpi_boot_table_prepare (void);
>void acpi_boot_table_init (void);
>int acpi_mps_check (void);
>int acpi_numa_init (void);
>
>int acpi_locate_initial_tables (void);
>void acpi_reserve_initial_tables (void);
>void acpi_table_init_complete (void);
>int acpi_table_init (void);
># 252 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int acpi_table_parse(char *id, acpi_tbl_table_handler handler);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_table_parse_entries(char *id,
>  unsigned long table_size, int entry_id,
>  acpi_tbl_entry_handler handler, unsigned int max_entries);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_table_parse_entries_array(char *id,
>  unsigned long table_size, struct acpi_subtable_proc *proc,
>  int proc_num, unsigned int max_entries);
>int acpi_table_parse_madt(enum acpi_madt_type id,
>     acpi_tbl_entry_handler handler,
>     unsigned int max_entries);
>int __attribute__((__section__(".init.text"))) __attribute__((__cold__))
>acpi_table_parse_cedt(enum acpi_cedt_type id,
>        acpi_tbl_entry_handler_arg handler_arg, void *arg);
>
>int acpi_parse_mcfg (struct acpi_table_header *header);
>void acpi_table_print_madt_entry (struct acpi_subtable_header *madt);
>
>
>void acpi_numa_slit_init (struct acpi_table_slit *slit);
>
>
>void acpi_numa_processor_affinity_init (struct acpi_srat_cpu_affinity *pa);
>
>
>
>
>
>void acpi_numa_x2apic_affinity_init(struct acpi_srat_x2apic_cpu_affinity *pa);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>acpi_numa_gicc_affinity_init(struct acpi_srat_gicc_affinity *pa) { }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>acpi_arch_dma_setup(struct device *dev, u64 *dma_addr, u64 *dma_size) { }
>
>
>int acpi_numa_memory_affinity_init (struct acpi_srat_mem_affinity *ma);
>
>
>typedef u32 phys_cpuid_t;
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool invalid_logical_cpuid(u32 cpuid)
>{
> return (int)cpuid < 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool invalid_phys_cpuid(phys_cpuid_t phys_id)
>{
> return phys_id == (phys_cpuid_t)(-1);
>}
>
>
>bool acpi_duplicate_processor_id(int proc_id);
>
>struct acpi_processor_power;
>
>
>bool acpi_processor_claim_cst_control(void);
>int acpi_processor_evaluate_cst(acpi_handle handle, u32 cpu,
>    struct acpi_processor_power *info);
># 328 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int acpi_map_cpu(acpi_handle handle, phys_cpuid_t physid, u32 acpi_id,
>   int *pcpu);
>int acpi_unmap_cpu(int cpu);
>
>
>
>int acpi_get_ioapic_id(acpi_handle handle, u32 gsi_base, u64 *phys_addr);
>
>
>int acpi_register_ioapic(acpi_handle handle, u64 phys_addr, u32 gsi_base);
>int acpi_unregister_ioapic(acpi_handle handle, u32 gsi_base);
>int acpi_ioapic_registered(acpi_handle handle, u32 gsi_base);
>void acpi_irq_stats_init(void);
>extern u32 acpi_irq_handled;
>extern u32 acpi_irq_not_handled;
>extern unsigned int acpi_sci_irq;
>extern bool acpi_no_s5;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_sci_irq_valid(void)
>{
> return acpi_sci_irq != ((unsigned)-1);
>}
>
>extern int sbf_port;
>extern unsigned long acpi_realmode_flags;
>
>int acpi_register_gsi (struct device *dev, u32 gsi, int triggering, int polarity);
>int acpi_gsi_to_irq (u32 gsi, unsigned int *irq);
>int acpi_isa_irq_to_gsi (unsigned isa_irq, u32 *gsi);
>
>void acpi_set_irq_model(enum acpi_irq_model_id model,
>   struct fwnode_handle *(*)(u32));
>void acpi_set_gsi_to_irq_fallback(u32 (*)(u32));
>
>struct irq_domain *acpi_irq_create_hierarchy(unsigned int flags,
>          unsigned int size,
>          struct fwnode_handle *fwnode,
>          const struct irq_domain_ops *ops,
>          void *host_data);
>
>
>extern int acpi_get_override_irq(u32 gsi, int *trigger, int *polarity);
># 381 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>void acpi_unregister_gsi (u32 gsi);
>
>struct pci_dev;
>
>int acpi_pci_irq_enable (struct pci_dev *dev);
>void acpi_penalize_isa_irq(int irq, int active);
>bool acpi_isa_irq_available(int irq);
>
>void acpi_penalize_sci_irq(int irq, int trigger, int polarity);
>
>
>
>
>
>
>void acpi_pci_irq_disable (struct pci_dev *dev);
>
>extern int ec_read(u8 addr, u8 *val);
>extern int ec_write(u8 addr, u8 val);
>extern int ec_transaction(u8 command,
>                          const u8 *wdata, unsigned wdata_len,
>                          u8 *rdata, unsigned rdata_len);
>extern acpi_handle ec_get_handle(void);
>
>extern bool acpi_is_pnp_device(struct acpi_device *);
>
>
>
>typedef void (*wmi_notify_handler) (u32 value, void *context);
>
>extern acpi_status wmi_evaluate_method(const char *guid, u8 instance,
>     u32 method_id,
>     const struct acpi_buffer *in,
>     struct acpi_buffer *out);
>extern acpi_status wmi_query_block(const char *guid, u8 instance,
>     struct acpi_buffer *out);
>extern acpi_status wmi_set_block(const char *guid, u8 instance,
>     const struct acpi_buffer *in);
>extern acpi_status wmi_install_notify_handler(const char *guid,
>     wmi_notify_handler handler, void *data);
>extern acpi_status wmi_remove_notify_handler(const char *guid);
>extern acpi_status wmi_get_event_data(u32 event, struct acpi_buffer *out);
>extern bool wmi_has_guid(const char *guid);
>extern char *wmi_get_acpi_device_uid(const char *guid);
># 441 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>extern char acpi_video_backlight_string[];
>extern long acpi_is_video_device(acpi_handle handle);
>extern int acpi_blacklisted(void);
>extern void acpi_osi_setup(char *str);
>extern bool acpi_osi_is_win8(void);
>
>
>int acpi_map_pxm_to_node(int pxm);
>int acpi_get_node(acpi_handle handle);
># 465 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int pxm_to_online_node(int pxm)
>{
> int node = pxm_to_node(pxm);
>
> return numa_map_to_online_node(node);
>}
># 485 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>extern int acpi_paddr_to_node(u64 start_addr, u64 size);
>
>extern int pnpacpi_disabled;
>
>
>
>bool acpi_dev_resource_memory(struct acpi_resource *ares, struct resource *res);
>bool acpi_dev_resource_io(struct acpi_resource *ares, struct resource *res);
>bool acpi_dev_resource_address_space(struct acpi_resource *ares,
>         struct resource_win *win);
>bool acpi_dev_resource_ext_address_space(struct acpi_resource *ares,
>      struct resource_win *win);
>unsigned long acpi_dev_irq_flags(u8 triggering, u8 polarity, u8 shareable);
>unsigned int acpi_dev_get_irq_type(int triggering, int polarity);
>bool acpi_dev_resource_interrupt(struct acpi_resource *ares, int index,
>     struct resource *res);
>
>void acpi_dev_free_resource_list(struct list_head *list);
>int acpi_dev_get_resources(struct acpi_device *adev, struct list_head *list,
>      int (*preproc)(struct acpi_resource *, void *),
>      void *preproc_data);
>int acpi_dev_get_dma_resources(struct acpi_device *adev,
>          struct list_head *list);
>int acpi_dev_filter_resource_type(struct acpi_resource *ares,
>      unsigned long types);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_dev_filter_resource_type_cb(struct acpi_resource *ares,
>         void *arg)
>{
> return acpi_dev_filter_resource_type(ares, (unsigned long)arg);
>}
>
>struct acpi_device *acpi_resource_consumer(struct resource *res);
>
>int acpi_check_resource_conflict(const struct resource *res);
>
>int acpi_check_region(resource_size_t start, resource_size_t n,
>        const char *name);
>
>acpi_status acpi_release_memory(acpi_handle handle, struct resource *res,
>    u32 level);
>
>int acpi_resources_are_enforced(void);
>
>
>extern int acpi_check_s4_hw_signature;
>
>
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_old_suspend_ordering(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_nvs_nosave(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_nvs_nosave_s3(void);
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) acpi_sleep_no_blacklist(void);
>
>
>int acpi_register_wakeup_handler(
> int wake_irq, bool (*wakeup)(void *context), void *context);
>void acpi_unregister_wakeup_handler(
> bool (*wakeup)(void *context), void *context);
>
>struct acpi_osc_context {
> char *uuid_str;
> int rev;
> struct acpi_buffer cap;
> struct acpi_buffer ret;
>};
>
>acpi_status acpi_run_osc(acpi_handle handle, struct acpi_osc_context *context);
># 588 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>extern bool osc_sb_apei_support_acked;
>extern bool osc_pc_lpi_support_confirmed;
>extern bool osc_sb_native_usb4_support_confirmed;
>extern bool osc_sb_cppc2_support_acked;
>extern bool osc_cpc_flexible_adr_space_confirmed;
>
>
>
>
>
>
>
>extern u32 osc_sb_native_usb4_control;
># 629 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 acpi_osc_ctx_get_pci_control(struct acpi_osc_context *context)
>{
> u32 *ret = context->ret.pointer;
>
> return ret[2];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 acpi_osc_ctx_get_cxl_control(struct acpi_osc_context *context)
>{
> u32 *ret = context->ret.pointer;
>
> return ret[4];
>}
># 689 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>enum acpi_predicate {
> all_versions,
> less_than_or_equal,
> equal,
> greater_than_or_equal,
>};
>
>
>struct acpi_platform_list {
> char oem_id[6 +1];
> char oem_table_id[8 +1];
> u32 oem_revision;
> char *table;
> enum acpi_predicate pred;
> char *reason;
> u32 data;
>};
>int acpi_match_platform_list(const struct acpi_platform_list *plat);
>
>extern void acpi_early_init(void);
>extern void acpi_subsystem_init(void);
>extern void arch_post_acpi_subsys_init(void);
>
>extern int acpi_nvs_register(__u64 start, __u64 size);
>
>extern int acpi_nvs_for_each_region(int (*func)(__u64, __u64, void *),
>        void *data);
>
>const struct acpi_device_id *acpi_match_device(const struct acpi_device_id *ids,
>            const struct device *dev);
>
>const void *acpi_device_get_match_data(const struct device *dev);
>extern bool acpi_driver_match_device(struct device *dev,
>         const struct device_driver *drv);
>int acpi_device_uevent_modalias(struct device *, struct kobj_uevent_env *);
>int acpi_device_modalias(struct device *, char *, int);
>
>struct platform_device *acpi_create_platform_device(struct acpi_device *,
>          const struct property_entry *);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_device_set_enumerated(struct acpi_device *adev)
>{
> adev->flags.visited = true;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void acpi_device_clear_enumerated(struct acpi_device *adev)
>{
> adev->flags.visited = false;
>}
>
>enum acpi_reconfig_event {
> ACPI_RECONFIG_DEVICE_ADD = 0,
> ACPI_RECONFIG_DEVICE_REMOVE,
>};
>
>int acpi_reconfig_notifier_register(struct notifier_block *nb);
>int acpi_reconfig_notifier_unregister(struct notifier_block *nb);
># 768 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int acpi_get_local_address(acpi_handle handle, u32 *addr);
>const char *acpi_get_subsystem_id(acpi_handle handle);
># 1059 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int acpi_ioapic_add(acpi_handle root);
>
>
>
>
>
>void acpi_os_set_prepare_sleep(int (*func)(u8 sleep_state,
>          u32 pm1a_ctrl, u32 pm1b_ctrl));
>
>acpi_status acpi_os_prepare_sleep(u8 sleep_state,
>      u32 pm1a_control, u32 pm1b_control);
>
>void acpi_os_set_prepare_extended_sleep(int (*func)(u8 sleep_state,
>            u32 val_a, u32 val_b));
>
>acpi_status acpi_os_prepare_extended_sleep(u8 sleep_state,
>        u32 val_a, u32 val_b);
>
>struct acpi_s2idle_dev_ops {
> struct list_head list_node;
> void (*prepare)(void);
> void (*restore)(void);
>};
>int acpi_register_lps0_dev(struct acpi_s2idle_dev_ops *arg);
>void acpi_unregister_lps0_dev(struct acpi_s2idle_dev_ops *arg);
>
>
>void arch_reserve_mem_area(acpi_physical_address addr, size_t size);
># 1098 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int acpi_dev_suspend(struct device *dev, bool wakeup);
>int acpi_dev_resume(struct device *dev);
>int acpi_subsys_runtime_suspend(struct device *dev);
>int acpi_subsys_runtime_resume(struct device *dev);
>int acpi_dev_pm_attach(struct device *dev, bool power_on);
>bool acpi_storage_d3(struct device *dev);
>bool acpi_dev_state_d0(struct device *dev);
># 1123 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int acpi_subsys_prepare(struct device *dev);
>void acpi_subsys_complete(struct device *dev);
>int acpi_subsys_suspend_late(struct device *dev);
>int acpi_subsys_suspend_noirq(struct device *dev);
>int acpi_subsys_suspend(struct device *dev);
>int acpi_subsys_freeze(struct device *dev);
>int acpi_subsys_poweroff(struct device *dev);
>void acpi_ec_mark_gpe_for_wake(void);
>void acpi_ec_set_gpe_wake_mask(u8 action);
># 1145 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>__attribute__((__format__(printf, 3, 4)))
>void acpi_handle_printk(const char *level, acpi_handle handle,
>   const char *fmt, ...);
>void acpi_evaluation_failure_warn(acpi_handle handle, const char *name,
>      acpi_status status);
># 1159 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>__attribute__((__format__(printf, 3, 4)))
>void __acpi_handle_debug(struct _ddebug *descriptor, acpi_handle handle, const char *fmt, ...);
># 1203 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>bool acpi_gpio_get_irq_resource(struct acpi_resource *ares,
>    struct acpi_resource_gpio **agpio);
>bool acpi_gpio_get_io_resource(struct acpi_resource *ares,
>          struct acpi_resource_gpio **agpio);
>int acpi_dev_gpio_irq_get_by(struct acpi_device *adev, const char *name, int index);
># 1226 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_dev_gpio_irq_get(struct acpi_device *adev, int index)
>{
> return acpi_dev_gpio_irq_get_by(adev, ((void *)0), index);
>}
>
>
>
>
>int acpi_dev_get_property(const struct acpi_device *adev, const char *name,
>     acpi_object_type type, const union acpi_object **obj);
>int __acpi_node_get_property_reference(const struct fwnode_handle *fwnode,
>    const char *name, size_t index, size_t num_args,
>    struct fwnode_reference_args *args);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_node_get_property_reference(
>    const struct fwnode_handle *fwnode,
>    const char *name, size_t index,
>    struct fwnode_reference_args *args)
>{
> return __acpi_node_get_property_reference(fwnode, name, index,
>  8, args);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool acpi_dev_has_props(const struct acpi_device *adev)
>{
> return !list_empty(&adev->data.properties);
>}
>
>struct acpi_device_properties *
>acpi_data_add_props(struct acpi_device_data *data, const guid_t *guid,
>      union acpi_object *properties);
>
>int acpi_node_prop_get(const struct fwnode_handle *fwnode, const char *propname,
>         void **valptr);
>
>struct fwnode_handle *acpi_get_next_subnode(const struct fwnode_handle *fwnode,
>         struct fwnode_handle *child);
>
>struct acpi_probe_entry;
>typedef bool (*acpi_probe_entry_validate_subtbl)(struct acpi_subtable_header *,
>       struct acpi_probe_entry *);
># 1283 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>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;
>};
># 1319 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>int __acpi_probe_device_table(struct acpi_probe_entry *start, int nr);
># 1396 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>void acpi_table_upgrade(void);
>
>
>
>
>
>extern bool acpi_has_watchdog(void);
>
>
>
>
>
>extern bool qdf2400_e44_present;
>int acpi_parse_spcr(bool enable_earlycon, bool enable_console);
># 1420 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>int acpi_irq_get(acpi_handle handle, unsigned int index, struct resource *res)
>{
> return -22;
>}
>
>
>
>int lpit_read_residency_count_address(u64 *address);
># 1443 "/usr/src/linux-5.14.21-150500.53/include/linux/acpi.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int acpi_pptt_cpu_is_thread(unsigned int cpu)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int find_acpi_cpu_topology(unsigned int cpu, int level)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int find_acpi_cpu_topology_cluster(unsigned int cpu)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int find_acpi_cpu_topology_package(unsigned int cpu)
>{
> return -22;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int find_acpi_cpu_topology_hetero_id(unsigned int cpu)
>{
> return -22;
>}
>
>
>
>extern void acpi_device_notify(struct device *dev);
>extern void acpi_device_notify_remove(struct device *dev);
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/regulator/consumer.h" 1
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/regulator/consumer.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/cgroupstats.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/cgroupstats.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/taskstats.h" 1
># 41 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/taskstats.h"
>struct taskstats {
>
>
>
>
>
> __u16 version;
> __u32 ac_exitcode;
>
>
>
>
> __u8 ac_flag;
> __u8 ac_nice;
># 72 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/taskstats.h"
> __u64 cpu_count __attribute__((aligned(8)));
> __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 __attribute__((aligned(8)));
>
> __u8 ac_pad[3];
> __u32 ac_uid __attribute__((aligned(8)));
>
> __u32 ac_gid;
> __u32 ac_pid;
> __u32 ac_ppid;
>
> __u32 ac_btime;
> __u64 ac_etime __attribute__((aligned(8)));
>
> __u64 ac_utime;
> __u64 ac_stime;
> __u64 ac_minflt;
> __u64 ac_majflt;
># 132 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/taskstats.h"
> __u64 coremem;
>
>
>
> __u64 virtmem;
>
>
>
>
> __u64 hiwater_rss;
> __u64 hiwater_vm;
>
>
> __u64 read_char;
> __u64 write_char;
> __u64 read_syscalls;
> __u64 write_syscalls;
>
>
>
>
> __u64 read_bytes;
> __u64 write_bytes;
> __u64 cancelled_write_bytes;
>
> __u64 nvcsw;
> __u64 nivcsw;
>
>
> __u64 ac_utimescaled;
> __u64 ac_stimescaled;
> __u64 cpu_scaled_run_real_total;
>
>
> __u64 freepages_count;
> __u64 freepages_delay_total;
>
>
> __u64 thrashing_count;
> __u64 thrashing_delay_total;
>
>
> __u64 ac_btime64;
>};
># 184 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/taskstats.h"
>enum {
> TASKSTATS_CMD_UNSPEC = 0,
> TASKSTATS_CMD_GET,
> TASKSTATS_CMD_NEW,
> __TASKSTATS_CMD_MAX,
>};
>
>
>
>enum {
> TASKSTATS_TYPE_UNSPEC = 0,
> TASKSTATS_TYPE_PID,
> TASKSTATS_TYPE_TGID,
> TASKSTATS_TYPE_STATS,
> TASKSTATS_TYPE_AGGR_PID,
> TASKSTATS_TYPE_AGGR_TGID,
> TASKSTATS_TYPE_NULL,
> __TASKSTATS_TYPE_MAX,
>};
>
>
>
>enum {
> TASKSTATS_CMD_ATTR_UNSPEC = 0,
> TASKSTATS_CMD_ATTR_PID,
> TASKSTATS_CMD_ATTR_TGID,
> TASKSTATS_CMD_ATTR_REGISTER_CPUMASK,
> TASKSTATS_CMD_ATTR_DEREGISTER_CPUMASK,
> __TASKSTATS_CMD_ATTR_MAX,
>};
># 21 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/cgroupstats.h" 2
># 32 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/cgroupstats.h"
>struct cgroupstats {
> __u64 nr_sleeping;
> __u64 nr_running;
> __u64 nr_stopped;
> __u64 nr_uninterruptible;
>
> __u64 nr_io_wait;
>};
>
>
>
>
>
>
>
>enum {
> CGROUPSTATS_CMD_UNSPEC = __TASKSTATS_CMD_MAX,
> CGROUPSTATS_CMD_GET,
> CGROUPSTATS_CMD_NEW,
> __CGROUPSTATS_CMD_MAX,
>};
>
>
>
>enum {
> CGROUPSTATS_TYPE_UNSPEC = 0,
> CGROUPSTATS_TYPE_CGROUP_STATS,
> __CGROUPSTATS_TYPE_MAX,
>};
>
>
>
>enum {
> CGROUPSTATS_CMD_ATTR_UNSPEC = 0,
> CGROUPSTATS_CMD_ATTR_FD,
> __CGROUPSTATS_CMD_ATTR_MAX,
>};
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 2
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/user_namespace.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/user_namespace.h"
>struct uid_gid_extent {
> u32 first;
> u32 lower_first;
> u32 count;
>};
>
>struct uid_gid_map {
> u32 nr_extents;
> union {
>  struct uid_gid_extent extent[5];
>  struct {
>   struct uid_gid_extent *forward;
>   struct uid_gid_extent *reverse;
>  };
> };
>};
>
>
>
>
>
>struct ucounts;
>
>enum ucount_type {
> UCOUNT_USER_NAMESPACES,
> UCOUNT_PID_NAMESPACES,
> UCOUNT_UTS_NAMESPACES,
> UCOUNT_IPC_NAMESPACES,
> UCOUNT_NET_NAMESPACES,
> UCOUNT_MNT_NAMESPACES,
> UCOUNT_CGROUP_NAMESPACES,
> UCOUNT_TIME_NAMESPACES,
>
> UCOUNT_INOTIFY_INSTANCES,
> UCOUNT_INOTIFY_WATCHES,
>
>
> UCOUNT_FANOTIFY_GROUPS,
> UCOUNT_FANOTIFY_MARKS,
>
> UCOUNT_RLIMIT_NPROC,
> UCOUNT_RLIMIT_MSGQUEUE,
> UCOUNT_RLIMIT_SIGPENDING,
> UCOUNT_RLIMIT_MEMLOCK,
> UCOUNT_COUNTS,
>};
>
>
>
>struct user_namespace {
> struct uid_gid_map uid_map;
> struct uid_gid_map gid_map;
> struct uid_gid_map projid_map;
> struct user_namespace *parent;
> int level;
> kuid_t owner;
> kgid_t group;
> struct ns_common ns;
> unsigned long flags;
>
>
> bool parent_could_setfcap;
>
>
>
>
>
>
>
> struct list_head keyring_name_list;
> struct key *user_keyring_register;
> struct rw_semaphore keyring_sem;
>
>
>
>
> struct key *persistent_keyring_register;
>
> struct work_struct work;
>
> struct ctl_table_set set;
> struct ctl_table_header *sysctls;
>
> struct ucounts *ucounts;
> long ucount_max[UCOUNT_COUNTS];
>} __attribute__((__designated_init__));
>
>struct ucounts {
> struct hlist_node node;
> struct user_namespace *ns;
> kuid_t uid;
> atomic_t count;
> atomic_long_t ucount[UCOUNT_COUNTS];
>};
>
>extern struct user_namespace init_user_ns;
>extern struct ucounts init_ucounts;
>
>bool setup_userns_sysctls(struct user_namespace *ns);
>void retire_userns_sysctls(struct user_namespace *ns);
>struct ucounts *inc_ucount(struct user_namespace *ns, kuid_t uid, enum ucount_type type);
>void dec_ucount(struct ucounts *ucounts, enum ucount_type type);
>struct ucounts *alloc_ucounts(struct user_namespace *ns, kuid_t uid);
>struct ucounts * __attribute__((__warn_unused_result__)) get_ucounts(struct ucounts *ucounts);
>void put_ucounts(struct ucounts *ucounts);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long get_ucounts_value(struct ucounts *ucounts, enum ucount_type type)
>{
> return atomic_long_read(&ucounts->ucount[type]);
>}
>
>long inc_rlimit_ucounts(struct ucounts *ucounts, enum ucount_type type, long v);
>bool dec_rlimit_ucounts(struct ucounts *ucounts, enum ucount_type type, long v);
>long inc_rlimit_get_ucounts(struct ucounts *ucounts, enum ucount_type type);
>void dec_rlimit_put_ucounts(struct ucounts *ucounts, enum ucount_type type);
>bool is_ucounts_overlimit(struct ucounts *ucounts, enum ucount_type type, unsigned long max);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_rlimit_ucount_max(struct user_namespace *ns,
>  enum ucount_type type, unsigned long max)
>{
> ns->ucount_max[type] = max <= ((long)(~0UL >> 1)) ? max : ((long)(~0UL >> 1));
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct user_namespace *get_user_ns(struct user_namespace *ns)
>{
> if (ns)
>  refcount_inc(&ns->ns.count);
> return ns;
>}
>
>extern int create_user_ns(struct cred *new);
>extern int unshare_userns(unsigned long unshare_flags, struct cred **new_cred);
>extern void __put_user_ns(struct user_namespace *ns);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_user_ns(struct user_namespace *ns)
>{
> if (ns && refcount_dec_and_test(&ns->ns.count))
>  __put_user_ns(ns);
>}
>
>struct seq_operations;
>extern const struct seq_operations proc_uid_seq_operations;
>extern const struct seq_operations proc_gid_seq_operations;
>extern const struct seq_operations proc_projid_seq_operations;
>extern ssize_t proc_uid_map_write(struct file *, const char *, size_t, loff_t *);
>extern ssize_t proc_gid_map_write(struct file *, const char *, size_t, loff_t *);
>extern ssize_t proc_projid_map_write(struct file *, const char *, size_t, loff_t *);
>extern ssize_t proc_setgroups_write(struct file *, const char *, size_t, loff_t *);
>extern int proc_setgroups_show(struct seq_file *m, void *v);
>extern bool userns_may_setgroups(const struct user_namespace *ns);
>extern bool in_userns(const struct user_namespace *ancestor,
>         const struct user_namespace *child);
>extern bool current_in_userns(const struct user_namespace *target_ns);
>struct ns_common *ns_get_owner(struct ns_common *ns);
># 25 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel_stat.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel_stat.h"
>enum cpu_usage_stat {
> CPUTIME_USER,
> CPUTIME_NICE,
> CPUTIME_SYSTEM,
> CPUTIME_SOFTIRQ,
> CPUTIME_IRQ,
> CPUTIME_IDLE,
> CPUTIME_IOWAIT,
> CPUTIME_STEAL,
> CPUTIME_GUEST,
> CPUTIME_GUEST_NICE,
> NR_STATS,
>};
>
>struct kernel_cpustat {
> u64 cpustat[NR_STATS];
>};
>
>struct kernel_stat {
> unsigned long irqs_sum;
> unsigned int softirqs[NR_SOFTIRQS];
>};
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_kstat; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct kernel_stat) kstat;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_kernel_cpustat; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct kernel_cpustat) kernel_cpustat;
>
>
>
>
>
>
>
>extern unsigned long long nr_context_switches(void);
>
>extern unsigned int kstat_irqs_cpu(unsigned int irq, int cpu);
>extern void kstat_incr_irq_this_cpu(unsigned int irq);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void kstat_incr_softirqs_this_cpu(unsigned int irq)
>{
> ({ __this_cpu_preempt_check("add"); do { do { const void *__vpp_verify = (typeof((&(kstat.softirqs[irq])) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(kstat.softirqs[irq])) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((kstat.softirqs[irq])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((kstat.softirqs[irq])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq])) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((kstat.softirqs[irq])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((kstat.softirqs[irq])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((kstat.softirqs[irq])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((kstat.softirqs[irq])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq])) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((kstat.softirqs[irq])) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else if (pao_ID__ == -1) ({ asm ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq]))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((kstat.softirqs[irq])) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm ("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((kstat.softirqs[irq])) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int kstat_softirqs_cpu(unsigned int irq, int cpu)
>{
>       return (*({ do { const void *__vpp_verify = (typeof((&(kstat)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(kstat)))) *)((&(kstat))))); (typeof((typeof(*((&(kstat)))) *)((&(kstat))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })).softirqs[irq];
>}
>
>
>
>
>extern unsigned int kstat_irqs_usr(unsigned int irq);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int kstat_cpu_irqs_sum(unsigned int cpu)
>{
> return (*({ do { const void *__vpp_verify = (typeof((&(kstat)) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(kstat)))) *)((&(kstat))))); (typeof((typeof(*((&(kstat)))) *)((&(kstat))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); })).irqs_sum;
>}
>
>
>extern u64 kcpustat_field(struct kernel_cpustat *kcpustat,
>     enum cpu_usage_stat usage, int cpu);
>extern void kcpustat_cpu_fetch(struct kernel_cpustat *dst, int cpu);
># 98 "/usr/src/linux-5.14.21-150500.53/include/linux/kernel_stat.h"
>extern void account_user_time(struct task_struct *, u64);
>extern void account_guest_time(struct task_struct *, u64);
>extern void account_system_time(struct task_struct *, int, u64);
>extern void account_system_index_time(struct task_struct *, u64,
>          enum cpu_usage_stat);
>extern void account_steal_time(u64);
>extern void account_idle_time(u64);
>extern u64 get_idle_time(struct kernel_cpustat *kcs, int cpu);
>
>
>
>
>
>
>
>extern void account_process_tick(struct task_struct *, int user);
>
>
>extern void account_idle_ticks(unsigned long ticks);
># 27 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h" 1
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/u64_stats_sync.h" 1
># 68 "/usr/src/linux-5.14.21-150500.53/include/linux/u64_stats_sync.h"
>struct u64_stats_sync {
>
>
>
>};
>
>
># 1 "./arch/x86/include/generated/asm/local64.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/local64.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/types.h" 1
># 7 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/local64.h" 2
># 22 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/local64.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h"
>typedef struct {
> atomic_long_t a;
>} local_t;
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_inc(local_t *l)
>{
> asm volatile(" " "incq" " " "%0"
>       : "+m" (l->a.counter));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_dec(local_t *l)
>{
> asm volatile(" " "decq" " " "%0"
>       : "+m" (l->a.counter));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_add(long i, local_t *l)
>{
> asm volatile(" " "addq" " " "%1,%0"
>       : "+m" (l->a.counter)
>       : "ir" (i));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void local_sub(long i, local_t *l)
>{
> asm volatile(" " "subq" " " "%1,%0"
>       : "+m" (l->a.counter)
>       : "ir" (i));
>}
># 54 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool local_sub_and_test(long i, local_t *l)
>{
> return ({ bool c; asm volatile (" " "subq" " " " %[val], " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (l->a.counter), "=@cc" "e" (c) : [val] "er" (i) : "memory"); c; });
>}
># 67 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool local_dec_and_test(local_t *l)
>{
> return ({ bool c; asm volatile (" " "decq" " " " " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (l->a.counter), "=@cc" "e" (c) : : "memory"); c; });
>}
># 80 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool local_inc_and_test(local_t *l)
>{
> return ({ bool c; asm volatile (" " "incq" " " " " "%[var]" "\n\t/* output condition code " "e" "*/\n" : [var] "+m" (l->a.counter), "=@cc" "e" (c) : : "memory"); c; });
>}
># 94 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool local_add_negative(long i, local_t *l)
>{
> return ({ bool c; asm volatile (" " "addq" " " " %[val], " "%[var]" "\n\t/* output condition code " "s" "*/\n" : [var] "+m" (l->a.counter), "=@cc" "s" (c) : [val] "er" (i) : "memory"); c; });
>}
># 106 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/local.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long local_add_return(long i, local_t *l)
>{
> long __i = i;
> asm volatile(" " "xaddq" " " "%0, %1;"
>       : "+r" (i), "+m" (l->a.counter)
>       : : "memory");
> return i + __i;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long local_sub_return(long i, local_t *l)
>{
> return local_add_return(-i, l);
>}
># 23 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/local64.h" 2
>
>typedef struct {
> local_t a;
>} local64_t;
># 1 "./arch/x86/include/generated/asm/local64.h" 2
># 76 "/usr/src/linux-5.14.21-150500.53/include/linux/u64_stats_sync.h" 2
>
>typedef struct {
> local64_t v;
>} u64_stats_t ;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 u64_stats_read(const u64_stats_t *p)
>{
> return atomic_long_read(&(&(&p->v)->a)->a);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void u64_stats_set(u64_stats_t *p, u64 val)
>{
> atomic_long_set(&((&(&p->v)->a))->a, ((val)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void u64_stats_add(u64_stats_t *p, unsigned long val)
>{
> local_add((val),(&(&p->v)->a));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void u64_stats_inc(u64_stats_t *p)
>{
> local_inc(&(&p->v)->a);
>}
># 131 "/usr/src/linux-5.14.21-150500.53/include/linux/u64_stats_sync.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void u64_stats_init(struct u64_stats_sync *syncp)
>{
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void u64_stats_update_begin(struct u64_stats_sync *syncp)
>{
>
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void u64_stats_update_end(struct u64_stats_sync *syncp)
>{
>
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long
>u64_stats_update_begin_irqsave(struct u64_stats_sync *syncp)
>{
> unsigned long flags = 0;
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/u64_stats_sync.h"
> return flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>u64_stats_update_end_irqrestore(struct u64_stats_sync *syncp,
>    unsigned long flags)
>{
>
>
>
>
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int __u64_stats_fetch_begin(const struct u64_stats_sync *syncp)
>{
>
>
>
> return 0;
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int u64_stats_fetch_begin(const struct u64_stats_sync *syncp)
>{
>
>
>
> return __u64_stats_fetch_begin(syncp);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool __u64_stats_fetch_retry(const struct u64_stats_sync *syncp,
>      unsigned int start)
>{
>
>
>
> return false;
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool u64_stats_fetch_retry(const struct u64_stats_sync *syncp,
>      unsigned int start)
>{
>
>
>
> return __u64_stats_fetch_retry(syncp, start);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int u64_stats_fetch_begin_irq(const struct u64_stats_sync *syncp)
>{
>
>
>
>
>
> return __u64_stats_fetch_begin(syncp);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool u64_stats_fetch_retry_irq(const struct u64_stats_sync *syncp,
>          unsigned int start)
>{
>
>
>
>
>
> return __u64_stats_fetch_retry(syncp, start);
>}
># 21 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bpf-cgroup-defs.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/bpf-cgroup-defs.h"
>struct bpf_prog_array;
>
>enum cgroup_bpf_attach_type {
> CGROUP_BPF_ATTACH_TYPE_INVALID = -1,
> CGROUP_INET_INGRESS = 0,
> CGROUP_INET_EGRESS,
> CGROUP_INET_SOCK_CREATE,
> CGROUP_SOCK_OPS,
> CGROUP_DEVICE,
> CGROUP_INET4_BIND,
> CGROUP_INET6_BIND,
> CGROUP_INET4_CONNECT,
> CGROUP_INET6_CONNECT,
> CGROUP_INET4_POST_BIND,
> CGROUP_INET6_POST_BIND,
> CGROUP_UDP4_SENDMSG,
> CGROUP_UDP6_SENDMSG,
> CGROUP_SYSCTL,
> CGROUP_UDP4_RECVMSG,
> CGROUP_UDP6_RECVMSG,
> CGROUP_GETSOCKOPT,
> CGROUP_SETSOCKOPT,
> CGROUP_INET4_GETPEERNAME,
> CGROUP_INET6_GETPEERNAME,
> CGROUP_INET4_GETSOCKNAME,
> CGROUP_INET6_GETSOCKNAME,
> CGROUP_INET_SOCK_RELEASE,
> MAX_CGROUP_BPF_ATTACH_TYPE
>};
>
>struct cgroup_bpf {
>
> struct bpf_prog_array *effective[MAX_CGROUP_BPF_ATTACH_TYPE];
>
>
>
>
>
>
> struct list_head progs[MAX_CGROUP_BPF_ATTACH_TYPE];
> u32 flags[MAX_CGROUP_BPF_ATTACH_TYPE];
>
>
> struct list_head storages;
>
>
> struct bpf_prog_array *inactive;
>
>
> struct percpu_ref refcnt;
>
>
> struct work_struct release_work;
>};
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/psi_types.h" 1
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kthread.h" 1
>
>
>
>
>
>
>
>struct mm_struct;
>
>__attribute__((__format__(printf, 4, 5)))
>struct task_struct *kthread_create_on_node(int (*threadfn)(void *data),
>        void *data,
>        int node,
>        const char namefmt[], ...);
># 31 "/usr/src/linux-5.14.21-150500.53/include/linux/kthread.h"
>struct task_struct *kthread_create_on_cpu(int (*threadfn)(void *data),
>       void *data,
>       unsigned int cpu,
>       const char *namefmt);
>
>void set_kthread_struct(struct task_struct *p);
>
>void kthread_set_per_cpu(struct task_struct *k, int cpu);
>bool kthread_is_per_cpu(struct task_struct *k);
># 71 "/usr/src/linux-5.14.21-150500.53/include/linux/kthread.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct task_struct *
>kthread_run_on_cpu(int (*threadfn)(void *data), void *data,
>   unsigned int cpu, const char *namefmt)
>{
> struct task_struct *p;
>
> p = kthread_create_on_cpu(threadfn, data, cpu, namefmt);
> if (!IS_ERR(p))
>  wake_up_process(p);
>
> return p;
>}
>
>void free_kthread_struct(struct task_struct *k);
>void kthread_bind(struct task_struct *k, unsigned int cpu);
>void kthread_bind_mask(struct task_struct *k, const struct cpumask *mask);
>int kthread_stop(struct task_struct *k);
>bool kthread_should_stop(void);
>bool kthread_should_park(void);
>bool __kthread_should_park(struct task_struct *k);
>bool kthread_freezable_should_stop(bool *was_frozen);
>void *kthread_func(struct task_struct *k);
>void *kthread_data(struct task_struct *k);
>void *kthread_probe_data(struct task_struct *k);
>int kthread_park(struct task_struct *k);
>void kthread_unpark(struct task_struct *k);
>void kthread_parkme(void);
>
>int kthreadd(void *unused);
>extern struct task_struct *kthreadd_task;
>extern int tsk_fork_get_node(struct task_struct *tsk);
># 111 "/usr/src/linux-5.14.21-150500.53/include/linux/kthread.h"
>struct kthread_work;
>typedef void (*kthread_work_func_t)(struct kthread_work *work);
>void kthread_delayed_work_timer_fn(struct timer_list *t);
>
>enum {
> KTW_FREEZABLE = 1 << 0,
>};
>
>struct kthread_worker {
> unsigned int flags;
> raw_spinlock_t lock;
> struct list_head work_list;
> struct list_head delayed_work_list;
> struct task_struct *task;
> struct kthread_work *current_work;
>};
>
>struct kthread_work {
> struct list_head node;
> kthread_work_func_t func;
> struct kthread_worker *worker;
>
> int canceling;
>};
>
>struct kthread_delayed_work {
> struct kthread_work work;
> struct timer_list timer;
>};
># 181 "/usr/src/linux-5.14.21-150500.53/include/linux/kthread.h"
>extern void __kthread_init_worker(struct kthread_worker *worker,
>   const char *name, struct lock_class_key *key);
># 205 "/usr/src/linux-5.14.21-150500.53/include/linux/kthread.h"
>int kthread_worker_fn(void *worker_ptr);
>
>__attribute__((__format__(printf, 2, 3)))
>struct kthread_worker *
>kthread_create_worker(unsigned int flags, const char namefmt[], ...);
>
>__attribute__((__format__(printf, 3, 4))) struct kthread_worker *
>kthread_create_worker_on_cpu(int cpu, unsigned int flags,
>        const char namefmt[], ...);
>
>bool kthread_queue_work(struct kthread_worker *worker,
>   struct kthread_work *work);
>
>bool kthread_queue_delayed_work(struct kthread_worker *worker,
>    struct kthread_delayed_work *dwork,
>    unsigned long delay);
>
>bool kthread_mod_delayed_work(struct kthread_worker *worker,
>         struct kthread_delayed_work *dwork,
>         unsigned long delay);
>
>void kthread_flush_work(struct kthread_work *work);
>void kthread_flush_worker(struct kthread_worker *worker);
>
>bool kthread_cancel_work_sync(struct kthread_work *work);
>bool kthread_cancel_delayed_work_sync(struct kthread_delayed_work *work);
>
>void kthread_destroy_worker(struct kthread_worker *worker);
>
>void kthread_use_mm(struct mm_struct *mm);
>void kthread_unuse_mm(struct mm_struct *mm);
>
>struct cgroup_subsys_state;
>
>
>void kthread_associate_blkcg(struct cgroup_subsys_state *css);
>struct cgroup_subsys_state *kthread_blkcg(void);
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/psi_types.h" 2
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/psi_types.h"
>enum psi_task_count {
> NR_IOWAIT,
> NR_MEMSTALL,
> NR_RUNNING,
>
>
>
>
>
>
> NR_ONCPU,
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/psi_types.h"
> NR_MEMSTALL_RUNNING,
> NR_PSI_TASK_COUNTS = 5,
>};
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/psi_types.h"
>enum psi_res {
> PSI_IO,
> PSI_MEM,
> PSI_CPU,
> NR_PSI_RESOURCES = 3,
>};
>
>
>
>
>
>
>
>enum psi_states {
> PSI_IO_SOME,
> PSI_IO_FULL,
> PSI_MEM_SOME,
> PSI_MEM_FULL,
> PSI_CPU_SOME,
> PSI_CPU_FULL,
>
> PSI_NONIDLE,
> NR_PSI_STATES = 7,
>};
>
>enum psi_aggregators {
> PSI_AVGS = 0,
> PSI_POLL,
> NR_PSI_AGGREGATORS,
>};
>
>struct psi_group_cpu {
>
>
>
> seqcount_t seq __attribute__((__aligned__((1 << (6)))));
>
>
> unsigned int tasks[NR_PSI_TASK_COUNTS];
>
>
> u32 state_mask;
>
>
> u32 times[NR_PSI_STATES];
>
>
> u64 state_start;
>
>
>
>
> u32 times_prev[NR_PSI_AGGREGATORS][NR_PSI_STATES]
>   __attribute__((__aligned__((1 << (6)))));
>};
>
>
>struct psi_window {
>
> u64 size;
>
>
> u64 start_time;
>
>
> u64 start_value;
>
>
> u64 prev_growth;
>};
>
>struct psi_trigger {
>
> enum psi_states state;
>
>
> u64 threshold;
>
>
> struct list_head node;
>
>
> struct psi_group *group;
>
>
> wait_queue_head_t event_wait;
>
>
> int event;
>
>
> struct psi_window win;
>
>
>
>
>
> u64 last_event_time;
>};
>
>struct psi_group {
>
> struct mutex avgs_lock;
>
>
> struct psi_group_cpu *pcpu;
>
>
> u64 avg_total[NR_PSI_STATES - 1];
> u64 avg_last_update;
> u64 avg_next_update;
>
>
> struct delayed_work avgs_work;
>
>
> u64 total[NR_PSI_AGGREGATORS][NR_PSI_STATES - 1];
> unsigned long avg[NR_PSI_STATES - 1][3];
>
>
> struct task_struct *poll_task;
> struct timer_list poll_timer;
> wait_queue_head_t poll_wait;
> atomic_t poll_wakeup;
>
>
> struct mutex trigger_lock;
>
>
> struct list_head triggers;
> u32 nr_triggers[NR_PSI_STATES - 1];
> u32 poll_states;
> u64 poll_min_period;
>
>
> u64 polling_total[NR_PSI_STATES - 1];
> u64 polling_next_update;
> u64 polling_until;
>};
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h" 2
>
>
>
>struct cgroup;
>struct cgroup_root;
>struct cgroup_subsys;
>struct cgroup_taskset;
>struct kernfs_node;
>struct kernfs_ops;
>struct kernfs_open_file;
>struct seq_file;
>struct poll_table_struct;
>
>
>
>
>
>
>
>enum cgroup_subsys_id {
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup_subsys.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup_subsys.h"
>cpuset_cgrp_id,
>
>
>
>cpu_cgrp_id,
>
>
>
>cpuacct_cgrp_id,
>
>
>
>io_cgrp_id,
>
>
>
>memory_cgrp_id,
>
>
>
>devices_cgrp_id,
>
>
>
>freezer_cgrp_id,
>
>
>
>net_cls_cgrp_id,
>
>
>
>perf_event_cgrp_id,
>
>
>
>net_prio_cgrp_id,
>
>
>
>hugetlb_cgrp_id,
>
>
>
>pids_cgrp_id,
>
>
>
>rdma_cgrp_id,
>
>
>
>misc_cgrp_id,
># 45 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h" 2
> CGROUP_SUBSYS_COUNT,
>};
>
>
>
>enum {
> CSS_NO_REF = (1 << 0),
> CSS_ONLINE = (1 << 1),
> CSS_RELEASED = (1 << 2),
> CSS_VISIBLE = (1 << 3),
> CSS_DYING = (1 << 4),
>};
>
>
>enum {
>
> CGRP_NOTIFY_ON_RELEASE,
>
>
>
>
>
> CGRP_CPUSET_CLONE_CHILDREN,
>
>
> CGRP_FREEZE,
>
>
> CGRP_FROZEN,
>
>
> CGRP_KILL,
>};
>
>
>enum {
> CGRP_ROOT_NOPREFIX = (1 << 1),
> CGRP_ROOT_XATTR = (1 << 2),
>
>
>
>
>
>
> CGRP_ROOT_NS_DELEGATE = (1 << 3),
>
>
>
>
> CGRP_ROOT_CPUSET_V2_MODE = (1 << 4),
>
>
>
>
> CGRP_ROOT_MEMORY_LOCAL_EVENTS = (1 << 5),
>
>
>
>
> CGRP_ROOT_MEMORY_RECURSIVE_PROT = (1 << 6),
>};
>
>
>enum {
> CFTYPE_ONLY_ON_ROOT = (1 << 0),
> CFTYPE_NOT_ON_ROOT = (1 << 1),
> CFTYPE_NS_DELEGATABLE = (1 << 2),
>
> CFTYPE_NO_PREFIX = (1 << 3),
> CFTYPE_WORLD_WRITABLE = (1 << 4),
> CFTYPE_DEBUG = (1 << 5),
> CFTYPE_PRESSURE = (1 << 6),
>
>
> __CFTYPE_ONLY_ON_DFL = (1 << 16),
> __CFTYPE_NOT_ON_DFL = (1 << 17),
>};
>
>
>
>
>
>
>struct cgroup_file {
>
> struct kernfs_node *kn;
> unsigned long notified_at;
> struct timer_list notify_timer;
>};
># 142 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
>struct cgroup_subsys_state {
>
> struct cgroup *cgroup;
>
>
> struct cgroup_subsys *ss;
>
>
> struct percpu_ref refcnt;
>
>
> struct list_head sibling;
> struct list_head children;
>
>
> struct list_head rstat_css_node;
>
>
>
>
>
> int id;
>
> unsigned int flags;
>
>
>
>
>
>
>
> u64 serial_nr;
>
>
>
>
>
> atomic_t online_cnt;
>
>
> struct work_struct destroy_work;
> struct rcu_work destroy_rwork;
>
>
>
>
>
> struct cgroup_subsys_state *parent;
>};
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
>struct css_set {
>
>
>
>
>
> struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
>
>
> refcount_t refcount;
>
>
>
>
>
>
>
> struct css_set *dom_cset;
>
>
> struct cgroup *dfl_cgrp;
>
>
> int nr_tasks;
># 231 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> struct list_head tasks;
> struct list_head mg_tasks;
> struct list_head dying_tasks;
>
>
> struct list_head task_iters;
># 245 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> struct list_head e_cset_node[CGROUP_SUBSYS_COUNT];
>
>
> struct list_head threaded_csets;
> struct list_head threaded_csets_node;
>
>
>
>
>
> struct hlist_node hlist;
>
>
>
>
>
> struct list_head cgrp_links;
>
>
>
>
>
> struct list_head mg_src_preload_node;
> struct list_head mg_dst_preload_node;
> struct list_head mg_node;
># 278 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> struct cgroup *mg_src_cgrp;
> struct cgroup *mg_dst_cgrp;
> struct css_set *mg_dst_cset;
>
>
> bool dead;
>
>
> struct callback_head callback_head;
>};
>
>struct cgroup_base_stat {
> struct task_cputime cputime;
>};
># 313 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
>struct cgroup_rstat_cpu {
>
>
>
>
> struct u64_stats_sync bsync;
> struct cgroup_base_stat bstat;
>
>
>
>
>
> struct cgroup_base_stat last_bstat;
># 338 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> struct cgroup *updated_children;
> struct cgroup *updated_next;
>};
>
>struct cgroup_freezer_state {
>
> bool freeze;
>
>
> int e_freeze;
>
>
>
>
> int nr_frozen_descendants;
>
>
>
>
>
> int nr_frozen_tasks;
>};
>
>struct cgroup {
>
> struct cgroup_subsys_state self;
>
> unsigned long flags;
>
>
>
>
>
>
>
> int level;
>
>
> int max_depth;
># 389 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> int nr_descendants;
> int nr_dying_descendants;
> int max_descendants;
># 404 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> int nr_populated_csets;
> int nr_populated_domain_children;
> int nr_populated_threaded_children;
>
> int nr_threaded_children;
>
> struct kernfs_node *kn;
> struct cgroup_file procs_file;
> struct cgroup_file events_file;
># 421 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> u16 subtree_control;
> u16 subtree_ss_mask;
> u16 old_subtree_control;
> u16 old_subtree_ss_mask;
>
>
> struct cgroup_subsys_state *subsys[CGROUP_SUBSYS_COUNT];
>
> struct cgroup_root *root;
>
>
>
>
>
> struct list_head cset_links;
># 444 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> struct list_head e_csets[CGROUP_SUBSYS_COUNT];
># 453 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> struct cgroup *dom_cgrp;
> struct cgroup *old_dom_cgrp;
>
>
> struct cgroup_rstat_cpu *rstat_cpu;
> struct list_head rstat_css_list;
>
>
> struct cgroup_base_stat last_bstat;
> struct cgroup_base_stat bstat;
> struct prev_cputime prev_cputime;
>
>
>
>
>
> struct list_head pidlists;
> struct mutex pidlist_mutex;
>
>
> wait_queue_head_t offline_waitq;
>
>
> struct work_struct release_agent_work;
>
>
> struct psi_group psi;
>
>
> struct cgroup_bpf bpf;
>
>
> atomic_t congestion_count;
>
>
> struct cgroup_freezer_state freezer;
>
>
> u64 ancestor_ids[];
>};
>
>
>
>
>
>
>struct cgroup_root {
> struct kernfs_root *kf_root;
>
>
> unsigned int subsys_mask;
>
>
> int hierarchy_id;
>
>
> struct cgroup cgrp;
>
>
> u64 cgrp_ancestor_id_storage;
>
>
> atomic_t nr_cgrps;
>
>
> struct list_head root_list;
>
>
> unsigned int flags;
>
>
> char release_agent_path[4096];
>
>
> char name[64];
>};
># 537 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
>struct cftype {
>
>
>
>
>
> char name[64];
> unsigned long private;
>
>
>
>
>
> size_t max_write_len;
>
>
> unsigned int flags;
>
>
>
>
>
>
>
> unsigned int file_offset;
>
>
>
>
>
> struct cgroup_subsys *ss;
> struct list_head node;
> struct kernfs_ops *kf_ops;
>
> int (*open)(struct kernfs_open_file *of);
> void (*release)(struct kernfs_open_file *of);
>
>
>
>
>
> u64 (*read_u64)(struct cgroup_subsys_state *css, struct cftype *cft);
>
>
>
> s64 (*read_s64)(struct cgroup_subsys_state *css, struct cftype *cft);
>
>
> int (*seq_show)(struct seq_file *sf, void *v);
>
>
> void *(*seq_start)(struct seq_file *sf, loff_t *ppos);
> void *(*seq_next)(struct seq_file *sf, void *v, loff_t *ppos);
> void (*seq_stop)(struct seq_file *sf, void *v);
>
>
>
>
>
>
> int (*write_u64)(struct cgroup_subsys_state *css, struct cftype *cft,
>    u64 val);
>
>
>
> int (*write_s64)(struct cgroup_subsys_state *css, struct cftype *cft,
>    s64 val);
>
>
>
>
>
>
>
> ssize_t (*write)(struct kernfs_open_file *of,
>    char *buf, size_t nbytes, loff_t off);
>
> __poll_t (*poll)(struct kernfs_open_file *of,
>    struct poll_table_struct *pt);
>
>
>
>
>};
>
>
>
>
>
>struct cgroup_subsys {
> struct cgroup_subsys_state *(*css_alloc)(struct cgroup_subsys_state *parent_css);
> int (*css_online)(struct cgroup_subsys_state *css);
> void (*css_offline)(struct cgroup_subsys_state *css);
> void (*css_released)(struct cgroup_subsys_state *css);
> void (*css_free)(struct cgroup_subsys_state *css);
> void (*css_reset)(struct cgroup_subsys_state *css);
> void (*css_rstat_flush)(struct cgroup_subsys_state *css, int cpu);
> int (*css_extra_stat_show)(struct seq_file *seq,
>       struct cgroup_subsys_state *css);
>
> int (*can_attach)(struct cgroup_taskset *tset);
> void (*cancel_attach)(struct cgroup_taskset *tset);
> void (*attach)(struct cgroup_taskset *tset);
> void (*post_attach)(void);
> int (*can_fork)(struct task_struct *task,
>   struct css_set *cset);
> void (*cancel_fork)(struct task_struct *task, struct css_set *cset);
> void (*fork)(struct task_struct *task);
> void (*exit)(struct task_struct *task);
> void (*release)(struct task_struct *task);
> void (*bind)(struct cgroup_subsys_state *root_css);
>
> bool early_init:1;
># 662 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> bool implicit_on_dfl:1;
># 674 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> bool threaded:1;
>
>
> int id;
> const char *name;
>
>
> const char *legacy_name;
>
>
> struct cgroup_root *root;
>
>
> struct idr css_idr;
>
>
>
>
>
> struct list_head cfts;
>
>
>
>
>
> struct cftype *dfl_cftypes;
> struct cftype *legacy_cftypes;
># 709 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
> unsigned int depends_on;
>};
>
>extern struct percpu_rw_semaphore cgroup_threadgroup_rwsem;
># 721 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_threadgroup_change_begin(struct task_struct *tsk)
>{
> percpu_down_read(&cgroup_threadgroup_rwsem);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_threadgroup_change_end(struct task_struct *tsk)
>{
> percpu_up_read(&cgroup_threadgroup_rwsem);
>}
># 762 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup-defs.h"
>struct sock_cgroup_data {
> struct cgroup *cgroup;
>
> u32 classid;
>
>
> u16 prioidx;
>
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u16 sock_cgroup_prioidx(const struct sock_cgroup_data *skcd)
>{
>
> return ({ do { extern void __compiletime_assert_315(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(skcd->prioidx) == sizeof(char) || sizeof(skcd->prioidx) == sizeof(short) || sizeof(skcd->prioidx) == sizeof(int) || sizeof(skcd->prioidx) == sizeof(long)) || sizeof(skcd->prioidx) == sizeof(long long))) __compiletime_assert_315(); } while (0); (*(const volatile typeof( _Generic((skcd->prioidx), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (skcd->prioidx))) *)&(skcd->prioidx)); });
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 sock_cgroup_classid(const struct sock_cgroup_data *skcd)
>{
>
> return ({ do { extern void __compiletime_assert_316(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(skcd->classid) == sizeof(char) || sizeof(skcd->classid) == sizeof(short) || sizeof(skcd->classid) == sizeof(int) || sizeof(skcd->classid) == sizeof(long)) || sizeof(skcd->classid) == sizeof(long long))) __compiletime_assert_316(); } while (0); (*(const volatile typeof( _Generic((skcd->classid), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (skcd->classid))) *)&(skcd->classid)); });
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sock_cgroup_set_prioidx(struct sock_cgroup_data *skcd,
>        u16 prioidx)
>{
>
> do { do { extern void __compiletime_assert_317(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(skcd->prioidx) == sizeof(char) || sizeof(skcd->prioidx) == sizeof(short) || sizeof(skcd->prioidx) == sizeof(int) || sizeof(skcd->prioidx) == sizeof(long)) || sizeof(skcd->prioidx) == sizeof(long long))) __compiletime_assert_317(); } while (0); do { *(volatile typeof(skcd->prioidx) *)&(skcd->prioidx) = (prioidx); } while (0); } while (0);
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void sock_cgroup_set_classid(struct sock_cgroup_data *skcd,
>        u32 classid)
>{
>
> do { do { extern void __compiletime_assert_318(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(skcd->classid) == sizeof(char) || sizeof(skcd->classid) == sizeof(short) || sizeof(skcd->classid) == sizeof(int) || sizeof(skcd->classid) == sizeof(long)) || sizeof(skcd->classid) == sizeof(long long))) __compiletime_assert_318(); } while (0); do { *(volatile typeof(skcd->classid) *)&(skcd->classid) = (classid); } while (0); } while (0);
>
>}
># 29 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 2
>
>struct kernel_clone_args;
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>struct css_task_iter {
> struct cgroup_subsys *ss;
> unsigned int flags;
>
> struct list_head *cset_pos;
> struct list_head *cset_head;
>
> struct list_head *tcset_pos;
> struct list_head *tcset_head;
>
> struct list_head *task_pos;
>
> struct list_head *cur_tasks_head;
> struct css_set *cur_cset;
> struct css_set *cur_dcset;
> struct task_struct *cur_task;
> struct list_head iters_node;
>};
>
>extern struct file_system_type cgroup_fs_type;
>extern struct cgroup_root cgrp_dfl_root;
>extern struct css_set init_css_set;
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup_subsys.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup_subsys.h"
>extern struct cgroup_subsys cpuset_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys cpu_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys cpuacct_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys io_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys memory_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys devices_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys freezer_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys net_cls_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys perf_event_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys net_prio_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys hugetlb_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys pids_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys rdma_cgrp_subsys;
>
>
>
>extern struct cgroup_subsys misc_cgrp_subsys;
># 77 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup_subsys.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup_subsys.h"
>extern struct static_key_true cpuset_cgrp_subsys_enabled_key; extern struct static_key_true cpuset_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true cpu_cgrp_subsys_enabled_key; extern struct static_key_true cpu_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true cpuacct_cgrp_subsys_enabled_key; extern struct static_key_true cpuacct_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true io_cgrp_subsys_enabled_key; extern struct static_key_true io_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true memory_cgrp_subsys_enabled_key; extern struct static_key_true memory_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true devices_cgrp_subsys_enabled_key; extern struct static_key_true devices_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true freezer_cgrp_subsys_enabled_key; extern struct static_key_true freezer_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true net_cls_cgrp_subsys_enabled_key; extern struct static_key_true net_cls_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true perf_event_cgrp_subsys_enabled_key; extern struct static_key_true perf_event_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true net_prio_cgrp_subsys_enabled_key; extern struct static_key_true net_prio_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true hugetlb_cgrp_subsys_enabled_key; extern struct static_key_true hugetlb_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true pids_cgrp_subsys_enabled_key; extern struct static_key_true pids_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true rdma_cgrp_subsys_enabled_key; extern struct static_key_true rdma_cgrp_subsys_on_dfl_key;
>
>
>
>extern struct static_key_true misc_cgrp_subsys_enabled_key; extern struct static_key_true misc_cgrp_subsys_on_dfl_key;
># 83 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h" 2
># 99 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>bool css_has_online_children(struct cgroup_subsys_state *css);
>struct cgroup_subsys_state *css_from_id(int id, struct cgroup_subsys *ss);
>struct cgroup_subsys_state *cgroup_e_css(struct cgroup *cgroup,
>      struct cgroup_subsys *ss);
>struct cgroup_subsys_state *cgroup_get_e_css(struct cgroup *cgroup,
>          struct cgroup_subsys *ss);
>struct cgroup_subsys_state *css_tryget_online_from_dir(struct dentry *dentry,
>             struct cgroup_subsys *ss);
>
>struct cgroup *cgroup_get_from_path(const char *path);
>struct cgroup *cgroup_get_from_fd(int fd);
>
>int cgroup_attach_task_all(struct task_struct *from, struct task_struct *);
>int cgroup_transfer_tasks(struct cgroup *to, struct cgroup *from);
>
>int cgroup_add_dfl_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
>int cgroup_add_legacy_cftypes(struct cgroup_subsys *ss, struct cftype *cfts);
>int cgroup_rm_cftypes(struct cftype *cfts);
>void cgroup_file_notify(struct cgroup_file *cfile);
>
>int task_cgroup_path(struct task_struct *task, char *buf, size_t buflen);
>int cgroupstats_build(struct cgroupstats *stats, struct dentry *dentry);
>int proc_cgroup_show(struct seq_file *m, struct pid_namespace *ns,
>       struct pid *pid, struct task_struct *tsk);
>
>void cgroup_fork(struct task_struct *p);
>extern int cgroup_can_fork(struct task_struct *p,
>      struct kernel_clone_args *kargs);
>extern void cgroup_cancel_fork(struct task_struct *p,
>          struct kernel_clone_args *kargs);
>extern void cgroup_post_fork(struct task_struct *p,
>        struct kernel_clone_args *kargs);
>void cgroup_exit(struct task_struct *p);
>void cgroup_release(struct task_struct *p);
>void cgroup_free(struct task_struct *p);
>
>int cgroup_init_early(void);
>int cgroup_init(void);
>
>int cgroup_parse_float(const char *input, unsigned dec_shift, s64 *v);
>
>
>
>
>
>struct cgroup_subsys_state *css_next_child(struct cgroup_subsys_state *pos,
>        struct cgroup_subsys_state *parent);
>struct cgroup_subsys_state *css_next_descendant_pre(struct cgroup_subsys_state *pos,
>          struct cgroup_subsys_state *css);
>struct cgroup_subsys_state *css_rightmost_descendant(struct cgroup_subsys_state *pos);
>struct cgroup_subsys_state *css_next_descendant_post(struct cgroup_subsys_state *pos,
>           struct cgroup_subsys_state *css);
>
>struct task_struct *cgroup_taskset_first(struct cgroup_taskset *tset,
>      struct cgroup_subsys_state **dst_cssp);
>struct task_struct *cgroup_taskset_next(struct cgroup_taskset *tset,
>     struct cgroup_subsys_state **dst_cssp);
>
>void css_task_iter_start(struct cgroup_subsys_state *css, unsigned int flags,
>    struct css_task_iter *it);
>struct task_struct *css_task_iter_next(struct css_task_iter *it);
>void css_task_iter_end(struct css_task_iter *it);
># 311 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 cgroup_id(const struct cgroup *cgrp)
>{
> return cgrp->kn->id;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void css_get(struct cgroup_subsys_state *css)
>{
> if (!(css->flags & CSS_NO_REF))
>  percpu_ref_get(&css->refcnt);
>}
># 335 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void css_get_many(struct cgroup_subsys_state *css, unsigned int n)
>{
> if (!(css->flags & CSS_NO_REF))
>  percpu_ref_get_many(&css->refcnt, n);
>}
># 352 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool css_tryget(struct cgroup_subsys_state *css)
>{
> if (!(css->flags & CSS_NO_REF))
>  return percpu_ref_tryget(&css->refcnt);
> return true;
>}
># 369 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool css_tryget_online(struct cgroup_subsys_state *css)
>{
> if (!(css->flags & CSS_NO_REF))
>  return percpu_ref_tryget_live(&css->refcnt);
> return true;
>}
># 391 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool css_is_dying(struct cgroup_subsys_state *css)
>{
> return !(css->flags & CSS_NO_REF) && percpu_ref_is_dying(&css->refcnt);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void css_put(struct cgroup_subsys_state *css)
>{
> if (!(css->flags & CSS_NO_REF))
>  percpu_ref_put(&css->refcnt);
>}
># 415 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void css_put_many(struct cgroup_subsys_state *css, unsigned int n)
>{
> if (!(css->flags & CSS_NO_REF))
>  percpu_ref_put_many(&css->refcnt, n);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_get(struct cgroup *cgrp)
>{
> css_get(&cgrp->self);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cgroup_tryget(struct cgroup *cgrp)
>{
> return css_tryget(&cgrp->self);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_put(struct cgroup *cgrp)
>{
> css_put(&cgrp->self);
>}
># 480 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct css_set *task_css_set(struct task_struct *task)
>{
> return ({ typeof(*((task)->cgroups)) *________p1 = (typeof(*((task)->cgroups)) *)({ do { extern void __compiletime_assert_319(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(((task)->cgroups)) == sizeof(char) || sizeof(((task)->cgroups)) == sizeof(short) || sizeof(((task)->cgroups)) == sizeof(int) || sizeof(((task)->cgroups)) == sizeof(long)) || sizeof(((task)->cgroups)) == sizeof(long long))) __compiletime_assert_319(); } while (0); (*(const volatile typeof( _Generic((((task)->cgroups)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (((task)->cgroups)))) *)&(((task)->cgroups))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*((task)->cgroups)) *)(________p1)); });
>}
># 492 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup_subsys_state *task_css(struct task_struct *task,
>         int subsys_id)
>{
> return ({ typeof(*(((task))->cgroups)) *________p1 = (typeof(*(((task))->cgroups)) *)({ do { extern void __compiletime_assert_320(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((((task))->cgroups)) == sizeof(char) || sizeof((((task))->cgroups)) == sizeof(short) || sizeof((((task))->cgroups)) == sizeof(int) || sizeof((((task))->cgroups)) == sizeof(long)) || sizeof((((task))->cgroups)) == sizeof(long long))) __compiletime_assert_320(); } while (0); (*(const volatile typeof( _Generic(((((task))->cgroups)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((((task))->cgroups)))) *)&((((task))->cgroups))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(((task))->cgroups)) *)(________p1)); })->subsys[(subsys_id)];
>}
># 507 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup_subsys_state *
>task_get_css(struct task_struct *task, int subsys_id)
>{
> struct cgroup_subsys_state *css;
>
> rcu_read_lock();
> while (true) {
>  css = task_css(task, subsys_id);
>
>
>
>
>
>
>  if (__builtin_expect(!!(css_tryget(css)), 1))
>   break;
>  cpu_relax();
> }
> rcu_read_unlock();
> return css;
>}
># 537 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_css_is_root(struct task_struct *task, int subsys_id)
>{
> return ({ typeof(*(((task))->cgroups)) *________p1 = (typeof(*(((task))->cgroups)) *)({ do { extern void __compiletime_assert_321(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((((task))->cgroups)) == sizeof(char) || sizeof((((task))->cgroups)) == sizeof(short) || sizeof((((task))->cgroups)) == sizeof(int) || sizeof((((task))->cgroups)) == sizeof(long)) || sizeof((((task))->cgroups)) == sizeof(long long))) __compiletime_assert_321(); } while (0); (*(const volatile typeof( _Generic(((((task))->cgroups)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((((task))->cgroups)))) *)&((((task))->cgroups))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(((task))->cgroups)) *)(________p1)); })->subsys[(subsys_id)] ==
>  init_css_set.subsys[subsys_id];
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup *task_cgroup(struct task_struct *task,
>      int subsys_id)
>{
> return task_css(task, subsys_id)->cgroup;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup *task_dfl_cgroup(struct task_struct *task)
>{
> return task_css_set(task)->dfl_cgrp;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup *cgroup_parent(struct cgroup *cgrp)
>{
> struct cgroup_subsys_state *parent_css = cgrp->self.parent;
>
> if (parent_css)
>  return ({ void *__mptr = (void *)(parent_css); do { extern void __compiletime_assert_322(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(parent_css)), typeof(((struct cgroup *)0)->self)) && !__builtin_types_compatible_p(typeof(*(parent_css)), typeof(void))))) __compiletime_assert_322(); } while (0); ((struct cgroup *)(__mptr - __builtin_offsetof(struct cgroup, self))); });
> return ((void *)0);
>}
># 572 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cgroup_is_descendant(struct cgroup *cgrp,
>     struct cgroup *ancestor)
>{
> if (cgrp->root != ancestor->root || cgrp->level < ancestor->level)
>  return false;
> return cgrp->ancestor_ids[ancestor->level] == cgroup_id(ancestor);
>}
># 591 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup *cgroup_ancestor(struct cgroup *cgrp,
>          int ancestor_level)
>{
> if (cgrp->level < ancestor_level)
>  return ((void *)0);
> while (cgrp && cgrp->level > ancestor_level)
>  cgrp = cgroup_parent(cgrp);
> return cgrp;
>}
># 610 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_under_cgroup_hierarchy(struct task_struct *task,
>            struct cgroup *ancestor)
>{
> struct css_set *cset = task_css_set(task);
>
> return cgroup_is_descendant(cset->dfl_cgrp, ancestor);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cgroup_is_populated(struct cgroup *cgrp)
>{
> return cgrp->nr_populated_csets + cgrp->nr_populated_domain_children +
>  cgrp->nr_populated_threaded_children;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) ino_t cgroup_ino(struct cgroup *cgrp)
>{
> return kernfs_ino(cgrp->kn);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cftype *of_cft(struct kernfs_open_file *of)
>{
> return of->kn->priv;
>}
>
>struct cgroup_subsys_state *of_css(struct kernfs_open_file *of);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cftype *seq_cft(struct seq_file *seq)
>{
> return of_cft(seq->private);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup_subsys_state *seq_css(struct seq_file *seq)
>{
> return of_css(seq->private);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cgroup_name(struct cgroup *cgrp, char *buf, size_t buflen)
>{
> return kernfs_name(cgrp->kn, buf, buflen);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int cgroup_path(struct cgroup *cgrp, char *buf, size_t buflen)
>{
> return kernfs_path(cgrp->kn, buf, buflen);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pr_cont_cgroup_name(struct cgroup *cgrp)
>{
> pr_cont_kernfs_name(cgrp->kn);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pr_cont_cgroup_path(struct cgroup *cgrp)
>{
> pr_cont_kernfs_path(cgrp->kn);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct psi_group *cgroup_psi(struct cgroup *cgrp)
>{
> return &cgrp->psi;
>}
>
>bool cgroup_psi_enabled(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_init_kthreadd(void)
>{
>
>
>
>
>
> get_current()->no_cgroup_migration = 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_kthread_ready(void)
>{
>
>
>
>
> get_current()->no_cgroup_migration = 0;
>}
>
>void cgroup_path_from_kernfs_id(u64 id, char *buf, size_t buflen);
>struct cgroup *cgroup_get_from_id(u64 id);
># 766 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>void cgroup_rstat_updated(struct cgroup *cgrp, int cpu);
>void cgroup_rstat_flush(struct cgroup *cgrp);
>void cgroup_rstat_flush_irqsafe(struct cgroup *cgrp);
>void cgroup_rstat_flush_hold(struct cgroup *cgrp);
>void cgroup_rstat_flush_release(void);
>
>
>
>
>
>void cpuacct_charge(struct task_struct *tsk, u64 cputime);
>void cpuacct_account_field(struct task_struct *tsk, int index, u64 val);
>
>
>
>
>
>
>void __cgroup_account_cputime(struct cgroup *cgrp, u64 delta_exec);
>void __cgroup_account_cputime_field(struct cgroup *cgrp,
>        enum cpu_usage_stat index, u64 delta_exec);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_account_cputime(struct task_struct *task,
>       u64 delta_exec)
>{
> struct cgroup *cgrp;
>
> cpuacct_charge(task, delta_exec);
>
> rcu_read_lock();
> cgrp = task_dfl_cgroup(task);
> if (cgroup_parent(cgrp))
>  __cgroup_account_cputime(cgrp, delta_exec);
> rcu_read_unlock();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_account_cputime_field(struct task_struct *task,
>      enum cpu_usage_stat index,
>      u64 delta_exec)
>{
> struct cgroup *cgrp;
>
> cpuacct_account_field(task, index, delta_exec);
>
> rcu_read_lock();
> cgrp = task_dfl_cgroup(task);
> if (cgroup_parent(cgrp))
>  __cgroup_account_cputime_field(cgrp, index, delta_exec);
> rcu_read_unlock();
>}
># 833 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>void cgroup_sk_alloc(struct sock_cgroup_data *skcd);
>void cgroup_sk_clone(struct sock_cgroup_data *skcd);
>void cgroup_sk_free(struct sock_cgroup_data *skcd);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cgroup *sock_cgroup_ptr(struct sock_cgroup_data *skcd)
>{
> return skcd->cgroup;
>}
># 850 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>struct cgroup_namespace {
> struct ns_common ns;
> struct user_namespace *user_ns;
> struct ucounts *ucounts;
> struct css_set *root_cset;
>};
>
>extern struct cgroup_namespace init_cgroup_ns;
>
>
>
>void free_cgroup_ns(struct cgroup_namespace *ns);
>
>struct cgroup_namespace *copy_cgroup_ns(unsigned long flags,
>     struct user_namespace *user_ns,
>     struct cgroup_namespace *old_ns);
>
>int cgroup_path_ns(struct cgroup *cgrp, char *buf, size_t buflen,
>     struct cgroup_namespace *ns);
># 882 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void get_cgroup_ns(struct cgroup_namespace *ns)
>{
> if (ns)
>  refcount_inc(&ns->ns.count);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_cgroup_ns(struct cgroup_namespace *ns)
>{
> if (ns && refcount_dec_and_test(&ns->ns.count))
>  free_cgroup_ns(ns);
>}
>
>
>
>void cgroup_enter_frozen(void);
>void cgroup_leave_frozen(bool always_leave);
>void cgroup_update_frozen(struct cgroup *cgrp);
>void cgroup_freeze(struct cgroup *cgrp, bool freeze);
>void cgroup_freezer_migrate_task(struct task_struct *task, struct cgroup *src,
>     struct cgroup *dst);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool cgroup_task_frozen(struct task_struct *task)
>{
> return task->frozen;
>}
># 920 "/usr/src/linux-5.14.21-150500.53/include/linux/cgroup.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_bpf_get(struct cgroup *cgrp)
>{
> percpu_ref_get(&cgrp->bpf.refcnt);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_bpf_put(struct cgroup *cgrp)
>{
> percpu_ref_put(&cgrp->bpf.refcnt);
>}
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/page_counter.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/page_counter.h"
>struct page_counter {
> atomic_long_t usage;
> unsigned long min;
> unsigned long low;
> unsigned long high;
> unsigned long max;
>
>
> unsigned long emin;
> atomic_long_t min_usage;
> atomic_long_t children_min_usage;
>
>
> unsigned long elow;
> atomic_long_t low_usage;
> atomic_long_t children_low_usage;
>
>
> unsigned long watermark;
> unsigned long failcnt;
>
>
>
>
>
>
>
> struct page_counter *parent;
>};
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_counter_init(struct page_counter *counter,
>         struct page_counter *parent)
>{
> atomic_long_set(&counter->usage, 0);
> counter->max = (((long)(~0UL >> 1)) / ((1UL) << 12));
> counter->parent = parent;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long page_counter_read(struct page_counter *counter)
>{
> return atomic_long_read(&counter->usage);
>}
>
>void page_counter_cancel(struct page_counter *counter, unsigned long nr_pages);
>void page_counter_charge(struct page_counter *counter, unsigned long nr_pages);
>bool page_counter_try_charge(struct page_counter *counter,
>        unsigned long nr_pages,
>        struct page_counter **fail);
>void page_counter_uncharge(struct page_counter *counter, unsigned long nr_pages);
>void page_counter_set_min(struct page_counter *counter, unsigned long nr_pages);
>void page_counter_set_low(struct page_counter *counter, unsigned long nr_pages);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_counter_set_high(struct page_counter *counter,
>      unsigned long nr_pages)
>{
> do { do { extern void __compiletime_assert_323(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(counter->high) == sizeof(char) || sizeof(counter->high) == sizeof(short) || sizeof(counter->high) == sizeof(int) || sizeof(counter->high) == sizeof(long)) || sizeof(counter->high) == sizeof(long long))) __compiletime_assert_323(); } while (0); do { *(volatile typeof(counter->high) *)&(counter->high) = (nr_pages); } while (0); } while (0);
>}
>
>int page_counter_set_max(struct page_counter *counter, unsigned long nr_pages);
>int page_counter_memparse(const char *buf, const char *max,
>     unsigned long *nr_pages);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void page_counter_reset_watermark(struct page_counter *counter)
>{
> counter->watermark = page_counter_read(counter);
>}
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/vmpressure.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/vmpressure.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/eventfd.h" 1
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/eventfd.h"
>struct eventfd_ctx;
>struct file;
>
>
>
>void eventfd_ctx_put(struct eventfd_ctx *ctx);
>struct file *eventfd_fget(int fd);
>struct eventfd_ctx *eventfd_ctx_fdget(int fd);
>struct eventfd_ctx *eventfd_ctx_fileget(struct file *file);
>__u64 eventfd_signal(struct eventfd_ctx *ctx, __u64 n);
>__u64 eventfd_signal_mask(struct eventfd_ctx *ctx, __u64 n, unsigned mask);
>int eventfd_ctx_remove_wait_queue(struct eventfd_ctx *ctx, wait_queue_entry_t *wait,
>      __u64 *cnt);
>void eventfd_ctx_do_read(struct eventfd_ctx *ctx, __u64 *cnt);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool eventfd_signal_allowed(void)
>{
> return !get_current()->in_eventfd_signal;
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/vmpressure.h" 2
>
>struct vmpressure {
> unsigned long scanned;
> unsigned long reclaimed;
>
> unsigned long tree_scanned;
> unsigned long tree_reclaimed;
>
> spinlock_t sr_lock;
>
>
> struct list_head events;
>
> struct mutex events_lock;
>
> struct work_struct work;
>};
>
>struct mem_cgroup;
>
>
>extern void vmpressure(gfp_t gfp, struct mem_cgroup *memcg, bool tree,
>         unsigned long scanned, unsigned long reclaimed);
>extern void vmpressure_prio(gfp_t gfp, struct mem_cgroup *memcg, int prio);
>
>extern void vmpressure_init(struct vmpressure *vmpr);
>extern void vmpressure_cleanup(struct vmpressure *vmpr);
>extern struct vmpressure *memcg_to_vmpressure(struct mem_cgroup *memcg);
>extern struct mem_cgroup *vmpressure_to_memcg(struct vmpressure *vmpr);
>extern int vmpressure_register_event(struct mem_cgroup *memcg,
>         struct eventfd_ctx *eventfd,
>         const char *args);
>extern void vmpressure_unregister_event(struct mem_cgroup *memcg,
>     struct eventfd_ctx *eventfd);
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/flex_proportions.h" 1
># 28 "/usr/src/linux-5.14.21-150500.53/include/linux/flex_proportions.h"
>struct fprop_global {
>
> struct percpu_counter events;
>
> unsigned int period;
>
> seqcount_t sequence;
>};
>
>int fprop_global_init(struct fprop_global *p, gfp_t gfp);
>void fprop_global_destroy(struct fprop_global *p);
>bool fprop_new_period(struct fprop_global *p, int periods);
>
>
>
>
>struct fprop_local_single {
>
> unsigned long events;
>
> unsigned int period;
> raw_spinlock_t lock;
>};
>
>
>
>
>
>int fprop_local_init_single(struct fprop_local_single *pl);
>void fprop_local_destroy_single(struct fprop_local_single *pl);
>void __fprop_inc_single(struct fprop_global *p, struct fprop_local_single *pl);
>void fprop_fraction_single(struct fprop_global *p,
> struct fprop_local_single *pl, unsigned long *numerator,
> unsigned long *denominator);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void fprop_inc_single(struct fprop_global *p, struct fprop_local_single *pl)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __fprop_inc_single(p, pl);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>
>
>
>struct fprop_local_percpu {
>
> struct percpu_counter events;
>
> unsigned int period;
> raw_spinlock_t lock;
>};
>
>int fprop_local_init_percpu(struct fprop_local_percpu *pl, gfp_t gfp);
>void fprop_local_destroy_percpu(struct fprop_local_percpu *pl);
>void __fprop_inc_percpu(struct fprop_global *p, struct fprop_local_percpu *pl);
>void __fprop_inc_percpu_max(struct fprop_global *p, struct fprop_local_percpu *pl,
>       int max_frac);
>void fprop_fraction_percpu(struct fprop_global *p,
> struct fprop_local_percpu *pl, unsigned long *numerator,
> unsigned long *denominator);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>void fprop_inc_percpu(struct fprop_global *p, struct fprop_local_percpu *pl)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __fprop_inc_percpu(p, pl);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/backing-dev-defs.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/backing-dev-defs.h"
>struct page;
>struct device;
>struct dentry;
>
>
>
>
>enum wb_state {
> WB_registered,
> WB_writeback_running,
> WB_has_dirty_io,
> WB_start_all,
>};
>
>enum wb_congested_state {
> WB_async_congested,
> WB_sync_congested,
>};
>
>enum wb_stat_item {
> WB_RECLAIMABLE,
> WB_WRITEBACK,
> WB_DIRTIED,
> WB_WRITTEN,
> NR_WB_STAT_ITEMS
>};
>
>
>
>
>
>
>enum wb_reason {
> WB_REASON_BACKGROUND,
> WB_REASON_VMSCAN,
> WB_REASON_SYNC,
> WB_REASON_PERIODIC,
> WB_REASON_LAPTOP_TIMER,
> WB_REASON_FS_FREE_SPACE,
>
>
>
>
>
>
> WB_REASON_FORKER_THREAD,
> WB_REASON_FOREIGN_FLUSH,
>
> WB_REASON_MAX,
>};
>
>struct wb_completion {
> atomic_t cnt;
> wait_queue_head_t *waitq;
>};
># 107 "/usr/src/linux-5.14.21-150500.53/include/linux/backing-dev-defs.h"
>struct bdi_writeback {
> struct backing_dev_info *bdi;
>
> unsigned long state;
> unsigned long last_old_flush;
>
> struct list_head b_dirty;
> struct list_head b_io;
> struct list_head b_more_io;
> struct list_head b_dirty_time;
> spinlock_t list_lock;
>
> atomic_t writeback_inodes;
> struct percpu_counter stat[NR_WB_STAT_ITEMS];
>
> unsigned long congested;
>
> unsigned long bw_time_stamp;
> unsigned long dirtied_stamp;
> unsigned long written_stamp;
> unsigned long write_bandwidth;
> unsigned long avg_write_bandwidth;
>
>
>
>
>
>
>
> unsigned long dirty_ratelimit;
> unsigned long balanced_dirty_ratelimit;
>
> struct fprop_local_percpu completions;
> int dirty_exceeded;
> enum wb_reason start_all_reason;
>
> spinlock_t work_lock;
> struct list_head work_list;
> struct delayed_work dwork;
> struct delayed_work bw_dwork;
>
> unsigned long dirty_sleep;
>
> struct list_head bdi_node;
>
>
> struct percpu_ref refcnt;
> struct fprop_local_percpu memcg_completions;
> struct cgroup_subsys_state *memcg_css;
> struct cgroup_subsys_state *blkcg_css;
> struct list_head memcg_node;
> struct list_head blkcg_node;
> struct list_head b_attached;
> struct list_head offline_node;
>
> union {
>  struct work_struct release_work;
>  struct callback_head rcu;
> };
>
>};
>
>struct backing_dev_info {
> u64 id;
> struct rb_node rb_node;
> struct list_head bdi_list;
> unsigned long ra_pages;
> unsigned long io_pages;
>
> struct kref refcnt;
> unsigned int capabilities;
> unsigned int min_ratio;
> unsigned int max_ratio, max_prop_frac;
>
>
>
>
>
> atomic_long_t tot_write_bandwidth;
>
> struct bdi_writeback wb;
> struct list_head wb_list;
>
> struct xarray cgwb_tree;
> struct mutex cgwb_release_mutex;
> struct rw_semaphore wb_switch_rwsem;
>
> wait_queue_head_t wb_waitq;
>
> struct device *dev;
> char dev_name[64];
> struct device *owner;
>
> struct timer_list laptop_mode_wb_timer;
>
>
> struct dentry *debug_dir;
>
>};
>
>enum {
> BLK_RW_ASYNC = 0,
> BLK_RW_SYNC = 1,
>};
>
>void clear_bdi_congested(struct backing_dev_info *bdi, int sync);
>void set_bdi_congested(struct backing_dev_info *bdi, int sync);
>
>struct wb_lock_cookie {
> bool locked;
> unsigned long flags;
>};
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool wb_tryget(struct bdi_writeback *wb)
>{
> if (wb != &wb->bdi->wb)
>  return percpu_ref_tryget(&wb->refcnt);
> return true;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wb_get(struct bdi_writeback *wb)
>{
> if (wb != &wb->bdi->wb)
>  percpu_ref_get(&wb->refcnt);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wb_put_many(struct bdi_writeback *wb, unsigned long nr)
>{
> if (({ int __ret_warn_on = !!(!wb->bdi); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/backing-dev-defs.h"), "i" (250), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("324" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "324" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); })) {
>
>
>
>
>  return;
> }
>
> if (wb != &wb->bdi->wb)
>  percpu_ref_put_many(&wb->refcnt, nr);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wb_put(struct bdi_writeback *wb)
>{
> wb_put_many(wb, 1);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool wb_dying(struct bdi_writeback *wb)
>{
> return percpu_ref_is_dying(&wb->refcnt);
>}
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>struct page;
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>struct bio_vec {
> struct page *bv_page;
> unsigned int bv_len;
> unsigned int bv_offset;
>};
>
>struct bvec_iter {
> sector_t bi_sector;
>
> unsigned int bi_size;
>
> unsigned int bi_idx;
>
> unsigned int bi_bvec_done;
>
>} __attribute__((__packed__));
>
>struct bvec_iter_all {
> struct bio_vec bv;
> int idx;
> unsigned done;
>};
># 101 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bvec_iter_advance(const struct bio_vec *bv,
>  struct bvec_iter *iter, unsigned bytes)
>{
> unsigned int idx = iter->bi_idx;
>
> if (({ static bool __attribute__((__section__(".data.once"))) __already_done; bool __ret_do_once = !!(bytes > iter->bi_size); if (__builtin_expect(!!(__ret_do_once && !__already_done), 0)) { __already_done = true; ({ int __ret_warn_on = !!(1); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); __warn_printk("Attempted to advance past end of bvec iter\n"); do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" (
>                                                     "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
># 106 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>     ), "i" (
>                                                     107
># 106 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>     ), "i" ((1 << 0)|((1 << 3) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("325" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "325" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); }); } __builtin_expect(!!(__ret_do_once), 0); })
>                                                      ) {
>  iter->bi_size = 0;
>  return false;
> }
>
> iter->bi_size -= bytes;
> bytes += iter->bi_bvec_done;
>
> while (bytes && bytes >= bv[idx].bv_len) {
>  bytes -= bv[idx].bv_len;
>  idx++;
> }
>
> iter->bi_idx = idx;
> iter->bi_bvec_done = bytes;
> return true;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bvec_iter_advance_single(const struct bio_vec *bv,
>    struct bvec_iter *iter, unsigned int bytes)
>{
> unsigned int done = iter->bi_bvec_done + bytes;
>
> if (done == bv[iter->bi_idx].bv_len) {
>  done = 0;
>  iter->bi_idx++;
> }
> iter->bi_bvec_done = done;
> iter->bi_size -= bytes;
>}
># 157 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio_vec *bvec_init_iter_all(struct bvec_iter_all *iter_all)
>{
> iter_all->done = 0;
> iter_all->idx = 0;
>
> return &iter_all->bv;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bvec_advance(const struct bio_vec *bvec,
>    struct bvec_iter_all *iter_all)
>{
> struct bio_vec *bv = &iter_all->bv;
>
> if (iter_all->done) {
>  bv->bv_page++;
>  bv->bv_offset = 0;
> } else {
>  bv->bv_page = bvec->bv_page + (bvec->bv_offset >> 12);
>  bv->bv_offset = bvec->bv_offset & ~(~(((1UL) << 12)-1));
> }
> bv->bv_len = __builtin_choose_expr(((!!(sizeof((typeof((unsigned int)(((1UL) << 12) - bv->bv_offset)) *)1 == (typeof((unsigned int)(bvec->bv_len - iter_all->done)) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)(((1UL) << 12) - bv->bv_offset)) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned int)(bvec->bv_len - iter_all->done)) * 0l)) : (int *)8))))), (((unsigned int)(((1UL) << 12) - bv->bv_offset)) < ((unsigned int)(bvec->bv_len - iter_all->done)) ? ((unsigned int)(((1UL) << 12) - bv->bv_offset)) : ((unsigned int)(bvec->bv_len - iter_all->done))), ({ typeof((unsigned int)(((1UL) << 12) - bv->bv_offset)) __UNIQUE_ID___x326 = ((unsigned int)(((1UL) << 12) - bv->bv_offset)); typeof((unsigned int)(bvec->bv_len - iter_all->done)) __UNIQUE_ID___y327 = ((unsigned int)(bvec->bv_len - iter_all->done)); ((__UNIQUE_ID___x326) < (__UNIQUE_ID___y327) ? (__UNIQUE_ID___x326) : (__UNIQUE_ID___y327)); }))
>                                    ;
> iter_all->done += bv->bv_len;
>
> if (iter_all->done == bvec->bv_len) {
>  iter_all->idx++;
>  iter_all->done = 0;
> }
>}
># 194 "/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *bvec_kmap_local(struct bio_vec *bvec)
>{
> return kmap_local_page(bvec->bv_page) + bvec->bv_offset;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcpy_from_bvec(char *to, struct bio_vec *bvec)
>{
> memcpy_from_page(to, bvec->bv_page, bvec->bv_offset, bvec->bv_len);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcpy_to_bvec(struct bio_vec *bvec, const char *from)
>{
> memcpy_to_page(bvec->bv_page, bvec->bv_offset, from, bvec->bv_len);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memzero_bvec(struct bio_vec *bvec)
>{
> memzero_page(bvec->bv_page, bvec->bv_offset, bvec->bv_len);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *bvec_virt(struct bio_vec *bvec)
>{
> ({ int __ret_warn_on = !!(PageHighMem(bvec->bv_page)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/bvec.h"), "i" (240), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("328" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "328" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return lowmem_page_address(bvec->bv_page) + bvec->bv_offset;
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h" 2
>
>
>
>struct bio_set;
>struct bio;
>struct bio_integrity_payload;
>struct page;
>struct io_context;
>struct cgroup_subsys_state;
>typedef void (bio_end_io_t) (struct bio *);
>struct bio_crypt_ctx;
># 40 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
>struct block_device {
> sector_t bd_start_sect;
> sector_t bd_nr_sectors;
> struct disk_stats *bd_stats;
> unsigned long bd_stamp;
> bool bd_read_only;
> dev_t bd_dev;
> atomic_t bd_openers;
> struct inode * bd_inode;
> struct super_block * bd_super;
> void * bd_claiming;
> struct device bd_device;
> void * bd_holder;
> int bd_holders;
> bool bd_write_holder;
> struct kobject *bd_holder_dir;
> u8 bd_partno;
> spinlock_t bd_size_lock;
> struct gendisk * bd_disk;
> struct request_queue * bd_queue;
>
>
> int bd_fsfreeze_count;
>
> struct mutex bd_fsfreeze_mutex;
> struct super_block *bd_fsfreeze_sb;
>
> struct partition_meta_info *bd_meta_info;
>
> bool bd_make_it_fail;
>
>} __attribute__((__designated_init__));
># 90 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
>typedef u8 blk_status_t;
>typedef u16 blk_short_t;
># 181 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool blk_path_error(blk_status_t error)
>{
> switch (error) {
> case (( blk_status_t)1):
> case (( blk_status_t)3):
> case (( blk_status_t)5):
> case (( blk_status_t)6):
> case (( blk_status_t)7):
> case (( blk_status_t)8):
>  return false;
> }
>
>
> return true;
>}
># 215 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
>struct bio_issue {
> u64 value;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 __bio_issue_time(u64 time)
>{
> return time & ((1ULL << ((64 - 1) - 12)) - 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u64 bio_issue_time(struct bio_issue *issue)
>{
> return __bio_issue_time(issue->value);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) sector_t bio_issue_size(struct bio_issue *issue)
>{
> return ((issue->value & (((1ULL << 12) - 1) << ((64 - 1) - 12))) >> ((64 - 1) - 12));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_issue_init(struct bio_issue *issue,
>           sector_t size)
>{
> size &= (1ULL << 12) - 1;
> issue->value = ((issue->value & (~((1ULL << (64 - 1)) - 1))) |
>   (ktime_get_ns() & ((1ULL << ((64 - 1) - 12)) - 1)) |
>   ((u64)size << ((64 - 1) - 12)));
>}
>
>typedef unsigned int blk_qc_t;
>
>
>
>
>
>
>struct bio {
> struct bio *bi_next;
> struct block_device *bi_bdev;
> unsigned int bi_opf;
>
>
> unsigned short bi_flags;
> unsigned short bi_ioprio;
> blk_status_t bi_status;
> atomic_t __bi_remaining;
>
> struct bvec_iter bi_iter;
>
> blk_qc_t bi_cookie;
> bio_end_io_t *bi_end_io;
> void *bi_private;
>
>
>
>
>
>
>
> struct blkcg_gq *bi_blkg;
> struct bio_issue bi_issue;
>
> u64 bi_iocost_cost;
>
>
>
>
> struct bio_crypt_ctx *bi_crypt_context;
>
>
> union {
>
>  struct bio_integrity_payload *bi_integrity;
>
> };
>
> unsigned short bi_vcnt;
>
>
>
>
>
> unsigned short bi_max_vecs;
>
> atomic_t __bi_cnt;
>
> struct bio_vec *bi_io_vec;
>
> struct bio_set *bi_pool;
>
>
>
>
>
>
> struct bio_vec bi_inline_vecs[];
>};
>
>
>
>
>
>
>
>enum {
> BIO_NO_PAGE_REF,
> BIO_CLONED,
> BIO_BOUNCED,
> BIO_WORKINGSET,
> BIO_QUIET,
> BIO_CHAIN,
> BIO_REFFED,
> BIO_THROTTLED,
>
> BIO_TRACE_COMPLETION,
>
> BIO_CGROUP_ACCT,
> BIO_QOS_THROTTLED,
> BIO_QOS_MERGED,
> BIO_REMAPPED,
> BIO_ZONE_WRITE_LOCKED,
> BIO_FLAG_LAST
>};
>
>typedef __u32 blk_mq_req_flags_t;
># 357 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
>enum req_opf {
>
> REQ_OP_READ = 0,
>
> REQ_OP_WRITE = 1,
>
> REQ_OP_FLUSH = 2,
>
> REQ_OP_DISCARD = 3,
>
> REQ_OP_SECURE_ERASE = 5,
>
> REQ_OP_WRITE_ZEROES = 9,
>
> REQ_OP_ZONE_OPEN = 10,
>
> REQ_OP_ZONE_CLOSE = 11,
>
> REQ_OP_ZONE_FINISH = 12,
>
> REQ_OP_ZONE_APPEND = 13,
>
> REQ_OP_ZONE_RESET = 15,
>
> REQ_OP_ZONE_RESET_ALL = 17,
>
>
> REQ_OP_DRV_IN = 34,
> REQ_OP_DRV_OUT = 35,
>
> REQ_OP_LAST,
>};
>
>enum req_flag_bits {
> __REQ_FAILFAST_DEV =
>  8,
> __REQ_FAILFAST_TRANSPORT,
> __REQ_FAILFAST_DRIVER,
> __REQ_SYNC,
> __REQ_META,
> __REQ_PRIO,
> __REQ_NOMERGE,
> __REQ_IDLE,
> __REQ_INTEGRITY,
> __REQ_FUA,
> __REQ_PREFLUSH,
> __REQ_RAHEAD,
> __REQ_BACKGROUND,
> __REQ_NOWAIT,
>
>
>
>
>
>
>
> __REQ_CGROUP_PUNT,
> __REQ_POLLED,
> __REQ_ALLOC_CACHE,
> __REQ_SWAP,
> __REQ_DRV,
>
>
>
>
>
> __REQ_NOUNMAP,
>
> __REQ_NR_BITS,
>};
># 457 "/usr/src/linux-5.14.21-150500.53/include/linux/blk_types.h"
>enum stat_group {
> STAT_READ,
> STAT_WRITE,
> STAT_DISCARD,
> STAT_FLUSH,
>
> NR_STAT_GROUPS
>};
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_set_op_attrs(struct bio *bio, unsigned op,
>  unsigned op_flags)
>{
> bio->bi_opf = op | op_flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool op_is_write(unsigned int op)
>{
> return (op & 1);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool op_is_flush(unsigned int op)
>{
> return op & ((1ULL << __REQ_FUA) | (1ULL << __REQ_PREFLUSH));
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool op_is_sync(unsigned int op)
>{
> return (op & ((1 << 8) - 1)) == REQ_OP_READ ||
>  (op & ((1ULL << __REQ_SYNC) | (1ULL << __REQ_FUA) | (1ULL << __REQ_PREFLUSH)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool op_is_discard(unsigned int op)
>{
> return (op & ((1 << 8) - 1)) == REQ_OP_DISCARD;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool op_is_zone_mgmt(enum req_opf op)
>{
> switch (op & ((1 << 8) - 1)) {
> case REQ_OP_ZONE_RESET:
> case REQ_OP_ZONE_OPEN:
> case REQ_OP_ZONE_CLOSE:
> case REQ_OP_ZONE_FINISH:
>  return true;
> default:
>  return false;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int op_stat_group(unsigned int op)
>{
> if (op_is_discard(op))
>  return STAT_DISCARD;
> return op_is_write(op);
>}
>
>struct blk_rq_stat {
> u64 mean;
> u64 min;
> u64 max;
> u32 nr_samples;
> u64 batch;
>};
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h" 2
>
>struct bio;
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_dirty_throttle_leaks; extern __attribute__((section(".data..percpu" ""))) __typeof__(int) dirty_throttle_leaks;
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>struct backing_dev_info;
>
>
>
>
>enum writeback_sync_modes {
> WB_SYNC_NONE,
> WB_SYNC_ALL,
>};
>
>
>
>
>
>
>struct writeback_control {
> long nr_to_write;
>
> long pages_skipped;
>
>
>
>
>
>
> loff_t range_start;
> loff_t range_end;
>
> enum writeback_sync_modes sync_mode;
>
> unsigned for_kupdate:1;
> unsigned for_background:1;
> unsigned tagged_writepages:1;
> unsigned for_reclaim:1;
> unsigned range_cyclic:1;
> unsigned for_sync:1;
> unsigned unpinned_fscache_wb:1;
>
>
>
>
>
>
>
> unsigned no_cgroup_owner:1;
>
> unsigned punt_to_cgroup:1;
>
>
> struct bdi_writeback *wb;
> struct inode *inode;
>
>
> int wb_id;
> int wb_lcand_id;
> int wb_tcand_id;
> size_t wb_bytes;
> size_t wb_lcand_bytes;
> size_t wb_tcand_bytes;
>
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int wbc_to_write_flags(struct writeback_control *wbc)
>{
> int flags = 0;
>
> if (wbc->punt_to_cgroup)
>  flags = (1ULL << __REQ_CGROUP_PUNT);
>
> if (wbc->sync_mode == WB_SYNC_ALL)
>  flags |= (1ULL << __REQ_SYNC);
> else if (wbc->for_kupdate || wbc->for_background)
>  flags |= (1ULL << __REQ_BACKGROUND);
>
> return flags;
>}
># 126 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>struct wb_domain {
> spinlock_t lock;
># 146 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
> struct fprop_global completions;
> struct timer_list period_timer;
> unsigned long period_time;
># 160 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
> unsigned long dirty_limit_tstamp;
> unsigned long dirty_limit;
>};
># 176 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wb_domain_size_changed(struct wb_domain *dom)
>{
> spin_lock(&dom->lock);
> dom->dirty_limit_tstamp = jiffies;
> dom->dirty_limit = 0;
> spin_unlock(&dom->lock);
>}
>
>
>
>
>struct bdi_writeback;
>void writeback_inodes_sb(struct super_block *, enum wb_reason reason);
>void writeback_inodes_sb_nr(struct super_block *, unsigned long nr,
>       enum wb_reason reason);
>void try_to_writeback_inodes_sb(struct super_block *sb, enum wb_reason reason);
>void sync_inodes_sb(struct super_block *);
>void wakeup_flusher_threads(enum wb_reason reason);
>void wakeup_flusher_threads_bdi(struct backing_dev_info *bdi,
>    enum wb_reason reason);
>void inode_wait_for_writeback(struct inode *inode);
>void inode_io_list_del(struct inode *inode);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wait_on_inode(struct inode *inode)
>{
> do { might_resched(); } while (0);
> wait_on_bit(&inode->i_state, 3, 0x0002);
>}
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h" 1
>
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/mempool.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/mempool.h"
>struct kmem_cache;
>
>typedef void * (mempool_alloc_t)(gfp_t gfp_mask, void *pool_data);
>typedef void (mempool_free_t)(void *element, void *pool_data);
>
>typedef 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;
>} mempool_t;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mempool_initialized(mempool_t *pool)
>{
> return pool->elements != ((void *)0);
>}
>
>void mempool_exit(mempool_t *pool);
>int mempool_init_node(mempool_t *pool, int min_nr, mempool_alloc_t *alloc_fn,
>        mempool_free_t *free_fn, void *pool_data,
>        gfp_t gfp_mask, int node_id);
>int mempool_init(mempool_t *pool, int min_nr, mempool_alloc_t *alloc_fn,
>   mempool_free_t *free_fn, void *pool_data);
>
>extern mempool_t *mempool_create(int min_nr, mempool_alloc_t *alloc_fn,
>   mempool_free_t *free_fn, void *pool_data);
>extern mempool_t *mempool_create_node(int min_nr, mempool_alloc_t *alloc_fn,
>   mempool_free_t *free_fn, void *pool_data,
>   gfp_t gfp_mask, int nid);
>
>extern int mempool_resize(mempool_t *pool, int new_min_nr);
>extern void mempool_destroy(mempool_t *pool);
>extern void *mempool_alloc(mempool_t *pool, gfp_t gfp_mask) __attribute__((__malloc__));
>extern void mempool_free(void *element, mempool_t *pool);
>
>
>
>
>
>
>void *mempool_alloc_slab(gfp_t gfp_mask, void *pool_data);
>void mempool_free_slab(void *element, void *pool_data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>mempool_init_slab_pool(mempool_t *pool, int min_nr, struct kmem_cache *kc)
>{
> return mempool_init(pool, min_nr, mempool_alloc_slab,
>       mempool_free_slab, (void *) kc);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) mempool_t *
>mempool_create_slab_pool(int min_nr, struct kmem_cache *kc)
>{
> return mempool_create(min_nr, mempool_alloc_slab, mempool_free_slab,
>         (void *) kc);
>}
>
>
>
>
>
>void *mempool_kmalloc(gfp_t gfp_mask, void *pool_data);
>void mempool_kfree(void *element, void *pool_data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mempool_init_kmalloc_pool(mempool_t *pool, int min_nr, size_t size)
>{
> return mempool_init(pool, min_nr, mempool_kmalloc,
>       mempool_kfree, (void *) size);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) mempool_t *mempool_create_kmalloc_pool(int min_nr, size_t size)
>{
> return mempool_create(min_nr, mempool_kmalloc, mempool_kfree,
>         (void *) size);
>}
>
>
>
>
>
>void *mempool_alloc_pages(gfp_t gfp_mask, void *pool_data);
>void mempool_free_pages(void *element, void *pool_data);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mempool_init_page_pool(mempool_t *pool, int min_nr, int order)
>{
> return mempool_init(pool, min_nr, mempool_alloc_pages,
>       mempool_free_pages, (void *)(long)order);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) mempool_t *mempool_create_page_pool(int min_nr, int order)
>{
> return mempool_create(min_nr, mempool_alloc_pages, mempool_free_pages,
>         (void *)(long)order);
>}
># 9 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/uio.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/uio.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/uio.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/uio.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/libc-compat.h" 1
># 14 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/uio.h" 2
>
>
>
>
>
>struct iovec
>{
> void *iov_base;
> __kernel_size_t iov_len;
>};
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/uio.h" 2
>
>struct page;
>struct pipe_inode_info;
>
>struct kvec {
> void *iov_base;
> size_t iov_len;
>};
>
>enum iter_type {
>
> ITER_IOVEC,
> ITER_KVEC,
> ITER_BVEC,
> ITER_PIPE,
> ITER_XARRAY,
> ITER_DISCARD,
>};
>
>struct iov_iter_state {
> size_t iov_offset;
> size_t count;
> unsigned long nr_segs;
>};
>
>struct iov_iter {
> u8 iter_type;
> bool data_source;
> size_t iov_offset;
> size_t count;
> union {
>  const struct iovec *iov;
>  const struct kvec *kvec;
>  const struct bio_vec *bvec;
>  struct xarray *xarray;
>  struct pipe_inode_info *pipe;
> };
> union {
>  unsigned long nr_segs;
>  struct {
>   unsigned int head;
>   unsigned int start_head;
>  };
>  loff_t xarray_start;
> };
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) enum iter_type iov_iter_type(const struct iov_iter *i)
>{
> return i->iter_type;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void iov_iter_save_state(struct iov_iter *iter,
>           struct iov_iter_state *state)
>{
> state->iov_offset = iter->iov_offset;
> state->count = iter->count;
> state->nr_segs = iter->nr_segs;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool iter_is_iovec(const struct iov_iter *i)
>{
> return iov_iter_type(i) == ITER_IOVEC;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool iov_iter_is_kvec(const struct iov_iter *i)
>{
> return iov_iter_type(i) == ITER_KVEC;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool iov_iter_is_bvec(const struct iov_iter *i)
>{
> return iov_iter_type(i) == ITER_BVEC;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool iov_iter_is_pipe(const struct iov_iter *i)
>{
> return iov_iter_type(i) == ITER_PIPE;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool iov_iter_is_discard(const struct iov_iter *i)
>{
> return iov_iter_type(i) == ITER_DISCARD;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool iov_iter_is_xarray(const struct iov_iter *i)
>{
> return iov_iter_type(i) == ITER_XARRAY;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned char iov_iter_rw(const struct iov_iter *i)
>{
> return i->data_source ? 1 : 0;
>}
># 113 "/usr/src/linux-5.14.21-150500.53/include/linux/uio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t iov_length(const struct iovec *iov, unsigned long nr_segs)
>{
> unsigned long seg;
> size_t ret = 0;
>
> for (seg = 0; seg < nr_segs; seg++)
>  ret += iov[seg].iov_len;
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct iovec iov_iter_iovec(const struct iov_iter *iter)
>{
> return (struct iovec) {
>  .iov_base = iter->iov->iov_base + iter->iov_offset,
>  .iov_len = __builtin_choose_expr(((!!(sizeof((typeof(iter->count) *)1 == (typeof(iter->iov->iov_len - iter->iov_offset) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(iter->count) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(iter->iov->iov_len - iter->iov_offset) * 0l)) : (int *)8))))), ((iter->count) < (iter->iov->iov_len - iter->iov_offset) ? (iter->count) : (iter->iov->iov_len - iter->iov_offset)), ({ typeof(iter->count) __UNIQUE_ID___x329 = (iter->count); typeof(iter->iov->iov_len - iter->iov_offset) __UNIQUE_ID___y330 = (iter->iov->iov_len - iter->iov_offset); ((__UNIQUE_ID___x329) < (__UNIQUE_ID___y330) ? (__UNIQUE_ID___x329) : (__UNIQUE_ID___y330)); }))
>                                                ,
> };
>}
>
>size_t copy_page_from_iter_atomic(struct page *page, unsigned offset,
>      size_t bytes, struct iov_iter *i);
>void iov_iter_advance(struct iov_iter *i, size_t bytes);
>void iov_iter_revert(struct iov_iter *i, size_t bytes);
>int iov_iter_fault_in_readable(const struct iov_iter *i, size_t bytes);
>size_t iov_iter_single_seg_count(const struct iov_iter *i);
>size_t copy_page_to_iter(struct page *page, size_t offset, size_t bytes,
>    struct iov_iter *i);
>size_t copy_page_from_iter(struct page *page, size_t offset, size_t bytes,
>    struct iov_iter *i);
>
>size_t _copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i);
>size_t _copy_from_iter(void *addr, size_t bytes, struct iov_iter *i);
>size_t _copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>size_t copy_to_iter(const void *addr, size_t bytes, struct iov_iter *i)
>{
> if (__builtin_expect(!!(!check_copy_size(addr, bytes, true)), 0))
>  return 0;
> else
>  return _copy_to_iter(addr, bytes, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>size_t copy_from_iter(void *addr, size_t bytes, struct iov_iter *i)
>{
> if (__builtin_expect(!!(!check_copy_size(addr, bytes, false)), 0))
>  return 0;
> else
>  return _copy_from_iter(addr, bytes, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>bool copy_from_iter_full(void *addr, size_t bytes, struct iov_iter *i)
>{
> size_t copied = copy_from_iter(addr, bytes, i);
> if (__builtin_expect(!!(copied == bytes), 1))
>  return true;
> iov_iter_revert(i, copied);
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>size_t copy_from_iter_nocache(void *addr, size_t bytes, struct iov_iter *i)
>{
> if (__builtin_expect(!!(!check_copy_size(addr, bytes, false)), 0))
>  return 0;
> else
>  return _copy_from_iter_nocache(addr, bytes, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>bool copy_from_iter_full_nocache(void *addr, size_t bytes, struct iov_iter *i)
>{
> size_t copied = copy_from_iter_nocache(addr, bytes, i);
> if (__builtin_expect(!!(copied == bytes), 1))
>  return true;
> iov_iter_revert(i, copied);
> return false;
>}
># 201 "/usr/src/linux-5.14.21-150500.53/include/linux/uio.h"
>size_t _copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i);
>
>
>
>
>
>size_t _copy_mc_to_iter(const void *addr, size_t bytes, struct iov_iter *i);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>size_t copy_from_iter_flushcache(void *addr, size_t bytes, struct iov_iter *i)
>{
> if (__builtin_expect(!!(!check_copy_size(addr, bytes, false)), 0))
>  return 0;
> else
>  return _copy_from_iter_flushcache(addr, bytes, i);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>size_t copy_mc_to_iter(void *addr, size_t bytes, struct iov_iter *i)
>{
> if (__builtin_expect(!!(!check_copy_size(addr, bytes, true)), 0))
>  return 0;
> else
>  return _copy_mc_to_iter(addr, bytes, i);
>}
>
>size_t iov_iter_zero(size_t bytes, struct iov_iter *);
>unsigned long iov_iter_alignment(const struct iov_iter *i);
>unsigned long iov_iter_gap_alignment(const struct iov_iter *i);
>void iov_iter_init(struct iov_iter *i, unsigned int direction, const struct iovec *iov,
>   unsigned long nr_segs, size_t count);
>void iov_iter_kvec(struct iov_iter *i, unsigned int direction, const struct kvec *kvec,
>   unsigned long nr_segs, size_t count);
>void iov_iter_bvec(struct iov_iter *i, unsigned int direction, const struct bio_vec *bvec,
>   unsigned long nr_segs, size_t count);
>void iov_iter_pipe(struct iov_iter *i, unsigned int direction, struct pipe_inode_info *pipe,
>   size_t count);
>void iov_iter_discard(struct iov_iter *i, unsigned int direction, size_t count);
>void iov_iter_xarray(struct iov_iter *i, unsigned int direction, struct xarray *xarray,
>       loff_t start, size_t count);
>ssize_t iov_iter_get_pages(struct iov_iter *i, struct page **pages,
>   size_t maxsize, unsigned maxpages, size_t *start);
>ssize_t iov_iter_get_pages_alloc(struct iov_iter *i, struct page ***pages,
>   size_t maxsize, size_t *start);
>int iov_iter_npages(const struct iov_iter *i, int maxpages);
>void iov_iter_restore(struct iov_iter *i, struct iov_iter_state *state);
>
>const void *dup_iter(struct iov_iter *new, struct iov_iter *old, gfp_t flags);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t iov_iter_count(const struct iov_iter *i)
>{
> return i->count;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void iov_iter_truncate(struct iov_iter *i, u64 count)
>{
>
>
>
>
>
>
> if (i->count > count)
>  i->count = count;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void iov_iter_reexpand(struct iov_iter *i, size_t count)
>{
> i->count = count;
>}
>
>struct csum_state {
> __wsum csum;
> size_t off;
>};
>
>size_t csum_and_copy_to_iter(const void *addr, size_t bytes, void *csstate, struct iov_iter *i);
>size_t csum_and_copy_from_iter(void *addr, size_t bytes, __wsum *csum, struct iov_iter *i);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) __attribute__((__warn_unused_result__))
>bool csum_and_copy_from_iter_full(void *addr, size_t bytes,
>      __wsum *csum, struct iov_iter *i)
>{
> size_t copied = csum_and_copy_from_iter(addr, bytes, csum, i);
> if (__builtin_expect(!!(copied == bytes), 1))
>  return true;
> iov_iter_revert(i, copied);
> return false;
>}
>size_t hash_and_copy_to_iter(const void *addr, size_t bytes, void *hashp,
>  struct iov_iter *i);
>
>struct iovec *iovec_from_user(const struct iovec *uvector,
>  unsigned long nr_segs, unsigned long fast_segs,
>  struct iovec *fast_iov, bool compat);
>ssize_t import_iovec(int type, const struct iovec *uvec,
>   unsigned nr_segs, unsigned fast_segs, struct iovec **iovp,
>   struct iov_iter *i);
>ssize_t __import_iovec(int type, const struct iovec *uvec,
>   unsigned nr_segs, unsigned fast_segs, struct iovec **iovp,
>   struct iov_iter *i, bool compat);
>int import_single_range(int type, void *buf, size_t len,
>   struct iovec *iov, struct iov_iter *i);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h" 2
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned int bio_max_segs(unsigned int nr_segs)
>{
> return __builtin_choose_expr(((!!(sizeof((typeof(nr_segs) *)1 == (typeof(256U) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)(nr_segs) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)(256U) * 0l)) : (int *)8))))), ((nr_segs) < (256U) ? (nr_segs) : (256U)), ({ typeof(nr_segs) __UNIQUE_ID___x331 = (nr_segs); typeof(256U) __UNIQUE_ID___y332 = (256U); ((__UNIQUE_ID___x331) < (__UNIQUE_ID___y332) ? (__UNIQUE_ID___x331) : (__UNIQUE_ID___y332)); }));
>}
># 52 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bio_has_data(struct bio *bio)
>{
> if (bio &&
>     bio->bi_iter.bi_size &&
>     ((bio)->bi_opf & ((1 << 8) - 1)) != REQ_OP_DISCARD &&
>     ((bio)->bi_opf & ((1 << 8) - 1)) != REQ_OP_SECURE_ERASE &&
>     ((bio)->bi_opf & ((1 << 8) - 1)) != REQ_OP_WRITE_ZEROES)
>  return true;
>
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bio_no_advance_iter(const struct bio *bio)
>{
> return ((bio)->bi_opf & ((1 << 8) - 1)) == REQ_OP_DISCARD ||
>        ((bio)->bi_opf & ((1 << 8) - 1)) == REQ_OP_SECURE_ERASE ||
>        ((bio)->bi_opf & ((1 << 8) - 1)) == REQ_OP_WRITE_ZEROES;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *bio_data(struct bio *bio)
>{
> if (bio_has_data(bio))
>  return lowmem_page_address((((&(((((bio))->bi_io_vec)))[(((((bio)->bi_iter)))).bi_idx])->bv_page) + (((&((((((bio))->bi_io_vec))))[((((((bio)->bi_iter))))).bi_idx])->bv_offset + (((((bio)->bi_iter)))).bi_bvec_done) / ((1UL) << 12)))) + (((&(((((bio))->bi_io_vec)))[(((((bio)->bi_iter)))).bi_idx])->bv_offset + ((((bio)->bi_iter))).bi_bvec_done) % ((1UL) << 12));
>
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bio_next_segment(const struct bio *bio,
>        struct bvec_iter_all *iter)
>{
> if (iter->idx >= bio->bi_vcnt)
>  return false;
>
> bvec_advance(&bio->bi_io_vec[iter->idx], iter);
> return true;
>}
># 96 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_advance_iter(const struct bio *bio,
>        struct bvec_iter *iter, unsigned int bytes)
>{
> iter->bi_sector += bytes >> 9;
>
> if (bio_no_advance_iter(bio))
>  iter->bi_size -= bytes;
> else
>  bvec_iter_advance(bio->bi_io_vec, iter, bytes);
>
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_advance_iter_single(const struct bio *bio,
>        struct bvec_iter *iter,
>        unsigned int bytes)
>{
> iter->bi_sector += bytes >> 9;
>
> if (bio_no_advance_iter(bio))
>  iter->bi_size -= bytes;
> else
>  bvec_iter_advance_single(bio->bi_io_vec, iter, bytes);
>}
>
>void __bio_advance(struct bio *, unsigned bytes);
># 134 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_advance(struct bio *bio, unsigned int nbytes)
>{
> if (nbytes == bio->bi_iter.bi_size) {
>  bio->bi_iter.bi_size = 0;
>  return;
> }
> __bio_advance(bio, nbytes);
>}
># 172 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned bio_segments(struct bio *bio)
>{
> unsigned segs = 0;
> struct bio_vec bv;
> struct bvec_iter iter;
>
>
>
>
>
>
> switch (((bio)->bi_opf & ((1 << 8) - 1))) {
> case REQ_OP_DISCARD:
> case REQ_OP_SECURE_ERASE:
> case REQ_OP_WRITE_ZEROES:
>  return 0;
> default:
>  break;
> }
>
> for (iter = ((bio)->bi_iter); (iter).bi_size && ((bv = ((struct bio_vec) { .bv_page = (((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_page) + (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) / ((1UL) << 12))), .bv_len = __builtin_choose_expr(((!!(sizeof((typeof((unsigned)(__builtin_choose_expr(((!!(sizeof((typeof((((((iter))))).bi_size) *)1 == (typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((((((iter))))).bi_size) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) * 0l)) : (int *)8))))), (((((((iter))))).bi_size) < ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) ? ((((((iter))))).bi_size) : ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done)), ({ typeof((((((iter))))).bi_size) __UNIQUE_ID___x333 = ((((((iter))))).bi_size); typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) __UNIQUE_ID___y334 = ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done); ((__UNIQUE_ID___x333) < (__UNIQUE_ID___y334) ? (__UNIQUE_ID___x333) : (__UNIQUE_ID___y334)); })))) *)1 == (typeof((unsigned)(((1UL) << 12) - (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) % ((1UL) << 12)))) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned)(__builtin_choose_expr(((!!(sizeof((typeof((((((iter))))).bi_size) *)1 == (typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((((((iter))))).bi_size) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) * 0l)) : (int *)8))))), (((((((iter))))).bi_size) < ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) ? ((((((iter))))).bi_size) : ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done)), ({ typeof((((((iter))))).bi_size) __UNIQUE_ID___x333 = ((((((iter))))).bi_size); typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) __UNIQUE_ID___y334 = ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done); ((__UNIQUE_ID___x333) < (__UNIQUE_ID___y334) ? (__UNIQUE_ID___x333) : (__UNIQUE_ID___y334)); })))) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((unsigned)(((1UL) << 12) - (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) % ((1UL) << 12)))) * 0l)) : (int *)8))))), (((unsigned)(__builtin_choose_expr(((!!(sizeof((typeof((((((iter))))).bi_size) *)1 == (typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((((((iter))))).bi_size) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) * 0l)) : (int *)8))))), (((((((iter))))).bi_size) < ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) ? ((((((iter))))).bi_size) : ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done)), ({ typeof((((((iter))))).bi_size) __UNIQUE_ID___x333 = ((((((iter))))).bi_size); typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) __UNIQUE_ID___y334 = ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done); ((__UNIQUE_ID___x333) < (__UNIQUE_ID___y334) ? (__UNIQUE_ID___x333) : (__UNIQUE_ID___y334)); })))) < ((unsigned)(((1UL) << 12) - (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) % ((1UL) << 12)))) ? ((unsigned)(__builtin_choose_expr(((!!(sizeof((typeof((((((iter))))).bi_size) *)1 == (typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((((((iter))))).bi_size) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) * 0l)) : (int *)8))))), (((((((iter))))).bi_size) < ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) ? ((((((iter))))).bi_size) : ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done)), ({ typeof((((((iter))))).bi_size) __UNIQUE_ID___x333 = ((((((iter))))).bi_size); typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) __UNIQUE_ID___y334 = ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done); ((__UNIQUE_ID___x333) < (__UNIQUE_ID___y334) ? (__UNIQUE_ID___x333) : (__UNIQUE_ID___y334)); })))) : ((unsigned)(((1UL) << 12) - (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) % ((1UL) << 12))))), ({ typeof((unsigned)(__builtin_choose_expr(((!!(sizeof((typeof((((((iter))))).bi_size) *)1 == (typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((((((iter))))).bi_size) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) * 0l)) : (int *)8))))), (((((((iter))))).bi_size) < ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) ? ((((((iter))))).bi_size) : ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done)), ({ typeof((((((iter))))).bi_size) __UNIQUE_ID___x333 = ((((((iter))))).bi_size); typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) __UNIQUE_ID___y334 = ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done); ((__UNIQUE_ID___x333) < (__UNIQUE_ID___y334) ? (__UNIQUE_ID___x333) : (__UNIQUE_ID___y334)); })))) __UNIQUE_ID___x335 = ((unsigned)(__builtin_choose_expr(((!!(sizeof((typeof((((((iter))))).bi_size) *)1 == (typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) *)1))) && ((sizeof(int) == sizeof(*(8 ? ((void *)((long)((((((iter))))).bi_size) * 0l)) : (int *)8))) && (sizeof(int) == sizeof(*(8 ? ((void *)((long)((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) * 0l)) : (int *)8))))), (((((((iter))))).bi_size) < ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) ? ((((((iter))))).bi_size) : ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done)), ({ typeof((((((iter))))).bi_size) __UNIQUE_ID___x333 = ((((((iter))))).bi_size); typeof((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done) __UNIQUE_ID___y334 = ((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_len - (((((iter))))).bi_bvec_done); ((__UNIQUE_ID___x333) < (__UNIQUE_ID___y334) ? (__UNIQUE_ID___x333) : (__UNIQUE_ID___y334)); })))); typeof((unsigned)(((1UL) << 12) - (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) % ((1UL) << 12)))) __UNIQUE_ID___y336 = ((unsigned)(((1UL) << 12) - (((&(((((((bio))->bi_io_vec)))))[(((((((iter))))))).bi_idx])->bv_offset + ((((((iter)))))).bi_bvec_done) % ((1UL) << 12)))); ((__UNIQUE_ID___x335) < (__UNIQUE_ID___y336) ? (__UNIQUE_ID___x335) : (__UNIQUE_ID___y336)); })), .bv_offset = (((&((((((bio))->bi_io_vec))))[((((((iter)))))).bi_idx])->bv_offset + (((((iter))))).bi_bvec_done) % ((1UL) << 12)), })), 1); bio_advance_iter_single((bio), &(iter), (bv).bv_len))
>  segs++;
>
> return segs;
>}
># 212 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_get(struct bio *bio)
>{
> bio->bi_flags |= (1 << BIO_REFFED);
> do { } while (0);
> atomic_inc(&bio->__bi_cnt);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_cnt_set(struct bio *bio, unsigned int count)
>{
> if (count != 1) {
>  bio->bi_flags |= (1 << BIO_REFFED);
>  asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> }
> atomic_set(&bio->__bi_cnt, count);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bio_flagged(struct bio *bio, unsigned int bit)
>{
> return (bio->bi_flags & (1U << bit)) != 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_set_flag(struct bio *bio, unsigned int bit)
>{
> bio->bi_flags |= (1U << bit);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_clear_flag(struct bio *bio, unsigned int bit)
>{
> bio->bi_flags &= ~(1U << bit);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio_vec *bio_first_bvec_all(struct bio *bio)
>{
> ({ int __ret_warn_on = !!(bio_flagged(bio, BIO_CLONED)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"), "i" (245), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("337" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "337" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return bio->bi_io_vec;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct page *bio_first_page_all(struct bio *bio)
>{
> return bio_first_bvec_all(bio)->bv_page;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio_vec *bio_last_bvec_all(struct bio *bio)
>{
> ({ int __ret_warn_on = !!(bio_flagged(bio, BIO_CLONED)); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"), "i" (256), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("338" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "338" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> return &bio->bi_io_vec[bio->bi_vcnt - 1];
>}
>
>enum bip_flags {
> BIP_BLOCK_INTEGRITY = 1 << 0,
> BIP_MAPPED_INTEGRITY = 1 << 1,
> BIP_CTRL_NOCHECK = 1 << 2,
> BIP_DISK_NOCHECK = 1 << 3,
> BIP_IP_CHECKSUM = 1 << 4,
>};
>
>
>
>
>struct bio_integrity_payload {
> struct bio *bip_bio;
>
> struct bvec_iter bip_iter;
>
> unsigned short bip_vcnt;
> unsigned short bip_max_vcnt;
> unsigned short bip_flags;
>
> struct bvec_iter bio_iter;
>
> struct work_struct bip_work;
>
> struct bio_vec *bip_vec;
> struct bio_vec bip_inline_vecs[];
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio_integrity_payload *bio_integrity(struct bio *bio)
>{
> if (bio->bi_opf & (1ULL << __REQ_INTEGRITY))
>  return bio->bi_integrity;
>
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bio_integrity_flagged(struct bio *bio, enum bip_flags flag)
>{
> struct bio_integrity_payload *bip = bio_integrity(bio);
>
> if (bip)
>  return bip->bip_flags & flag;
>
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) sector_t bip_get_seed(struct bio_integrity_payload *bip)
>{
> return bip->bip_iter.bi_sector;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bip_set_seed(struct bio_integrity_payload *bip,
>    sector_t seed)
>{
> bip->bip_iter.bi_sector = seed;
>}
>
>
>
>void bio_trim(struct bio *bio, sector_t offset, sector_t size);
>extern struct bio *bio_split(struct bio *bio, int sectors,
>        gfp_t gfp, struct bio_set *bs);
># 335 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio *bio_next_split(struct bio *bio, int sectors,
>      gfp_t gfp, struct bio_set *bs)
>{
> if (sectors >= (((bio)->bi_iter).bi_size >> 9))
>  return bio;
>
> return bio_split(bio, sectors, gfp, bs);
>}
>
>enum {
> BIOSET_NEED_BVECS = ((((1UL))) << (0)),
> BIOSET_NEED_RESCUER = ((((1UL))) << (1)),
> BIOSET_PERCPU_CACHE = ((((1UL))) << (2)),
>};
>extern int bioset_init(struct bio_set *, unsigned int, unsigned int, int flags);
>extern void bioset_exit(struct bio_set *);
>extern int biovec_init_pool(mempool_t *pool, int pool_entries);
>extern int bioset_init_from_src(struct bio_set *bs, struct bio_set *src);
>
>struct bio *bio_alloc_bioset(struct block_device *bdev, unsigned short nr_vecs,
>        unsigned int opf, gfp_t gfp_mask,
>        struct bio_set *bs);
>struct bio *bio_kmalloc(unsigned short nr_vecs, gfp_t gfp_mask);
>extern void bio_put(struct bio *);
>
>struct bio *bio_alloc_clone(struct block_device *bdev, struct bio *bio_src,
>  gfp_t gfp, struct bio_set *bs);
>int bio_init_clone(struct block_device *bdev, struct bio *bio,
>  struct bio *bio_src, gfp_t gfp);
>
>extern struct bio_set fs_bio_set;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio *bio_alloc(struct block_device *bdev,
>  unsigned short nr_vecs, unsigned int opf, gfp_t gfp_mask)
>{
> return bio_alloc_bioset(bdev, nr_vecs, opf, gfp_mask, &fs_bio_set);
>}
>
>void submit_bio(struct bio *bio);
>
>extern void bio_endio(struct bio *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_io_error(struct bio *bio)
>{
> bio->bi_status = (( blk_status_t)10);
> bio_endio(bio);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_wouldblock_error(struct bio *bio)
>{
> bio_set_flag(bio, BIO_QUIET);
> bio->bi_status = (( blk_status_t)12);
> bio_endio(bio);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int bio_iov_vecs_to_alloc(struct iov_iter *iter, int max_segs)
>{
> if (iov_iter_is_bvec(iter))
>  return 0;
> return iov_iter_npages(iter, max_segs);
>}
>
>struct request_queue;
>struct request;
>
>extern int submit_bio_wait(struct bio *bio);
>void bio_init(struct bio *bio, struct block_device *bdev, struct bio_vec *table,
>       unsigned short max_vecs, unsigned int opf);
>extern void bio_uninit(struct bio *);
>void bio_reset(struct bio *bio, struct block_device *bdev, unsigned int opf);
>void bio_chain(struct bio *, struct bio *);
>
>extern int bio_add_page(struct bio *, struct page *, unsigned int,unsigned int);
>extern int bio_add_pc_page(struct request_queue *, struct bio *, struct page *,
>      unsigned int, unsigned int);
>int bio_add_zone_append_page(struct bio *bio, struct page *page,
>        unsigned int len, unsigned int offset);
>void __bio_add_page(struct bio *bio, struct page *page,
>  unsigned int len, unsigned int off);
>int bio_iov_iter_get_pages(struct bio *bio, struct iov_iter *iter);
>void bio_iov_bvec_set(struct bio *bio, struct iov_iter *iter);
>void __bio_release_pages(struct bio *bio, bool mark_dirty);
>extern int bio_map_user_iov(struct request *, struct iov_iter *, gfp_t);
>extern void bio_set_pages_dirty(struct bio *bio);
>extern void bio_check_pages_dirty(struct bio *bio);
>
>extern void bio_copy_data_iter(struct bio *dst, struct bvec_iter *dst_iter,
>          struct bio *src, struct bvec_iter *src_iter);
>extern void bio_copy_data(struct bio *dst, struct bio *src);
>extern void bio_free_pages(struct bio *bio);
>void guard_bio_eod(struct bio *bio);
>void zero_fill_bio(struct bio *bio);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_release_pages(struct bio *bio, bool mark_dirty)
>{
> if (!bio_flagged(bio, BIO_NO_PAGE_REF))
>  __bio_release_pages(bio, mark_dirty);
>}
>
>extern const char *bio_devname(struct bio *bio, char *buffer);
>
>
>
>
>
>void bio_associate_blkg(struct bio *bio);
>void bio_associate_blkg_from_css(struct bio *bio,
>     struct cgroup_subsys_state *css);
>void bio_clone_blkg_association(struct bio *dst, struct bio *src);
># 458 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_set_dev(struct bio *bio, struct block_device *bdev)
>{
> bio_clear_flag(bio, BIO_REMAPPED);
> if (bio->bi_bdev != bdev)
>  bio_clear_flag(bio, BIO_THROTTLED);
> bio->bi_bdev = bdev;
> bio_associate_blkg(bio);
>}
># 474 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>struct bio_list {
> struct bio *head;
> struct bio *tail;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int bio_list_empty(const struct bio_list *bl)
>{
> return bl->head == ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_list_init(struct bio_list *bl)
>{
> bl->head = bl->tail = ((void *)0);
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned bio_list_size(const struct bio_list *bl)
>{
> unsigned sz = 0;
> struct bio *bio;
>
> for (bio = (bl)->head; bio; bio = bio->bi_next)
>  sz++;
>
> return sz;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_list_add(struct bio_list *bl, struct bio *bio)
>{
> bio->bi_next = ((void *)0);
>
> if (bl->tail)
>  bl->tail->bi_next = bio;
> else
>  bl->head = bio;
>
> bl->tail = bio;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_list_add_head(struct bio_list *bl, struct bio *bio)
>{
> bio->bi_next = bl->head;
>
> bl->head = bio;
>
> if (!bl->tail)
>  bl->tail = bio;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_list_merge(struct bio_list *bl, struct bio_list *bl2)
>{
> if (!bl2->head)
>  return;
>
> if (bl->tail)
>  bl->tail->bi_next = bl2->head;
> else
>  bl->head = bl2->head;
>
> bl->tail = bl2->tail;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_list_merge_head(struct bio_list *bl,
>           struct bio_list *bl2)
>{
> if (!bl2->head)
>  return;
>
> if (bl->head)
>  bl2->tail->bi_next = bl->head;
> else
>  bl->tail = bl2->tail;
>
> bl->head = bl2->head;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio *bio_list_peek(struct bio_list *bl)
>{
> return bl->head;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio *bio_list_pop(struct bio_list *bl)
>{
> struct bio *bio = bl->head;
>
> if (bio) {
>  bl->head = bl->head->bi_next;
>  if (!bl->head)
>   bl->tail = ((void *)0);
>
>  bio->bi_next = ((void *)0);
> }
>
> return bio;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct bio *bio_list_get(struct bio_list *bl)
>{
> struct bio *bio = bl->head;
>
> bl->head = bl->tail = ((void *)0);
>
> return bio;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_inc_remaining(struct bio *bio)
>{
> bio_set_flag(bio, BIO_CHAIN);
> do { } while (0);
> atomic_inc(&bio->__bi_remaining);
>}
># 602 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>struct bio_set {
> struct kmem_cache *bio_slab;
> unsigned int front_pad;
>
>
>
>
> struct bio_alloc_cache *cache;
>
> mempool_t bio_pool;
> mempool_t bvec_pool;
>
> mempool_t bio_integrity_pool;
> mempool_t bvec_integrity_pool;
>
>
> unsigned int back_pad;
>
>
>
>
> spinlock_t rescue_lock;
> struct bio_list rescue_list;
> struct work_struct rescue_work;
> struct workqueue_struct *rescue_workqueue;
>
>
>
>
> struct hlist_node cpuhp_dead;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool bioset_initialized(struct bio_set *bs)
>{
> return bs->bio_slab != ((void *)0);
>}
># 648 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>extern struct bio_integrity_payload *bio_integrity_alloc(struct bio *, gfp_t, unsigned int);
>extern int bio_integrity_add_page(struct bio *, struct page *, unsigned int, unsigned int);
>extern bool bio_integrity_prep(struct bio *);
>extern void bio_integrity_advance(struct bio *, unsigned int);
>extern void bio_integrity_trim(struct bio *);
>extern int bio_integrity_clone(struct bio *, struct bio *, gfp_t);
>extern int bioset_integrity_create(struct bio_set *, int);
>extern void bioset_integrity_free(struct bio_set *);
>extern void bio_integrity_init(void);
># 728 "/usr/src/linux-5.14.21-150500.53/include/linux/bio.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_set_polled(struct bio *bio, struct kiocb *kiocb)
>{
> bio->bi_opf |= (1ULL << __REQ_POLLED);
> if (!is_sync_kiocb(kiocb))
>  bio->bi_opf |= (1ULL << __REQ_NOWAIT);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void bio_clear_polled(struct bio *bio)
>{
>
> bio->bi_opf &= ~((1ULL << __REQ_POLLED) | (1ULL << __REQ_ALLOC_CACHE));
>}
>
>struct bio *blk_next_bio(struct bio *bio, struct block_device *bdev,
>  unsigned int nr_pages, unsigned int opf, gfp_t gfp);
># 210 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h" 2
>
>void __inode_attach_wb(struct inode *inode, struct page *page);
>void wbc_attach_and_unlock_inode(struct writeback_control *wbc,
>     struct inode *inode)
> ;
>void wbc_detach_inode(struct writeback_control *wbc);
>void wbc_account_cgroup_owner(struct writeback_control *wbc, struct page *page,
>         size_t bytes);
>int cgroup_writeback_by_id(u64 bdi_id, int memcg_id, unsigned long nr_pages,
>      enum wb_reason reason, struct wb_completion *done);
>void cgroup_writeback_umount(void);
>bool cleanup_offline_cgwb(struct bdi_writeback *wb);
># 232 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_attach_wb(struct inode *inode, struct page *page)
>{
> if (!inode->i_wb)
>  __inode_attach_wb(inode, page);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void inode_detach_wb(struct inode *inode)
>{
> if (inode->i_wb) {
>  ({ int __ret_warn_on = !!(!(inode->i_state & (1 << 6))); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"), "i" (247), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("339" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "339" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>  wb_put(inode->i_wb);
>  inode->i_wb = ((void *)0);
> }
>}
># 262 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wbc_attach_fdatawrite_inode(struct writeback_control *wbc,
>            struct inode *inode)
>{
> spin_lock(&inode->i_lock);
> inode_attach_wb(inode, ((void *)0));
> wbc_attach_and_unlock_inode(wbc, inode);
>}
># 280 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void wbc_init_bio(struct writeback_control *wbc, struct bio *bio)
>{
>
>
>
>
>
>
> if (wbc->wb)
>  bio_associate_blkg_from_css(bio, wbc->wb->blkcg_css);
>}
># 337 "/usr/src/linux-5.14.21-150500.53/include/linux/writeback.h"
>void laptop_io_completion(struct backing_dev_info *info);
>void laptop_sync_completion(void);
>void laptop_mode_sync(struct work_struct *work);
>void laptop_mode_timer_fn(struct timer_list *t);
>
>
>
>bool node_dirty_ok(struct pglist_data *pgdat);
>int wb_domain_init(struct wb_domain *dom, gfp_t gfp);
>
>void wb_domain_exit(struct wb_domain *dom);
>
>
>extern struct wb_domain global_wb_domain;
>
>
>extern int dirty_background_ratio;
>extern unsigned long dirty_background_bytes;
>extern int vm_dirty_ratio;
>extern unsigned long vm_dirty_bytes;
>extern unsigned int dirty_writeback_interval;
>extern unsigned int dirty_expire_interval;
>extern unsigned int dirtytime_expire_interval;
>extern int vm_highmem_is_dirtyable;
>extern int laptop_mode;
>
>int dirty_background_ratio_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *lenp, loff_t *ppos);
>int dirty_background_bytes_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *lenp, loff_t *ppos);
>int dirty_ratio_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *lenp, loff_t *ppos);
>int dirty_bytes_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *lenp, loff_t *ppos);
>int dirtytime_interval_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *lenp, loff_t *ppos);
>int dirty_writeback_centisecs_handler(struct ctl_table *table, int write,
>  void *buffer, size_t *lenp, loff_t *ppos);
>
>void global_dirty_limits(unsigned long *pbackground, unsigned long *pdirty);
>unsigned long wb_calc_thresh(struct bdi_writeback *wb, unsigned long thresh);
>
>void wb_update_bandwidth(struct bdi_writeback *wb);
>void balance_dirty_pages_ratelimited(struct address_space *mapping);
>bool wb_over_bg_thresh(struct bdi_writeback *wb);
>
>typedef int (*writepage_t)(struct page *page, struct writeback_control *wbc,
>    void *data);
>
>int generic_writepages(struct address_space *mapping,
>         struct writeback_control *wbc);
>void tag_pages_for_writeback(struct address_space *mapping,
>        unsigned long start, unsigned long end);
>int write_cache_pages(struct address_space *mapping,
>        struct writeback_control *wbc, writepage_t writepage,
>        void *data);
>int do_writepages(struct address_space *mapping, struct writeback_control *wbc);
>void writeback_set_ratelimit(void);
>void tag_pages_for_writeback(struct address_space *mapping,
>        unsigned long start, unsigned long end);
>
>void account_page_redirty(struct page *page);
>
>void sb_mark_inode_writeback(struct inode *inode);
>void sb_clear_inode_writeback(struct inode *inode);
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h" 2
>
>
>struct mem_cgroup;
>struct obj_cgroup;
>struct page;
>struct mm_struct;
>struct kmem_cache;
>
>
>enum memcg_stat_item {
> MEMCG_SWAP = NR_VM_NODE_STAT_ITEMS,
> MEMCG_SOCK,
> MEMCG_PERCPU_B,
> MEMCG_NR_STAT,
>};
>
>enum memcg_memory_event {
> MEMCG_LOW,
> MEMCG_HIGH,
> MEMCG_MAX,
> MEMCG_OOM,
> MEMCG_OOM_KILL,
> MEMCG_SWAP_HIGH,
> MEMCG_SWAP_MAX,
> MEMCG_SWAP_FAIL,
> MEMCG_NR_MEMORY_EVENTS,
>};
>
>struct mem_cgroup_reclaim_cookie {
> pg_data_t *pgdat;
> unsigned int generation;
>};
>
>
>
>
>
>
>struct mem_cgroup_id {
> int id;
> refcount_t ref;
>};
>
>
>
>
>
>
>
>enum mem_cgroup_events_target {
> MEM_CGROUP_TARGET_THRESH,
> MEM_CGROUP_TARGET_SOFTLIMIT,
> MEM_CGROUP_NTARGETS,
>};
>
>struct memcg_vmstats_percpu {
>
> long state[MEMCG_NR_STAT];
> unsigned long events[NR_VM_EVENT_ITEMS];
>
>
> long state_prev[MEMCG_NR_STAT];
> unsigned long events_prev[NR_VM_EVENT_ITEMS];
>
>
> unsigned long nr_page_events;
> unsigned long targets[MEM_CGROUP_NTARGETS];
>};
>
>struct memcg_vmstats {
>
> long state[MEMCG_NR_STAT];
> unsigned long events[NR_VM_EVENT_ITEMS];
>
>
> long state_pending[MEMCG_NR_STAT];
> unsigned long events_pending[NR_VM_EVENT_ITEMS];
>};
>
>struct mem_cgroup_reclaim_iter {
> struct mem_cgroup *position;
>
> unsigned int generation;
>};
>
>struct lruvec_stat {
> long count[NR_VM_NODE_STAT_ITEMS];
>};
>
>struct batched_lruvec_stat {
> s32 count[NR_VM_NODE_STAT_ITEMS];
>};
>
>
>
>
>
>struct shrinker_info {
> struct callback_head rcu;
> atomic_long_t *nr_deferred;
> unsigned long *map;
>};
>
>
>
>
>struct mem_cgroup_per_node {
> struct lruvec lruvec;
># 139 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
> struct lruvec_stat *lruvec_stat_local;
>
>
> struct batched_lruvec_stat *lruvec_stat_cpu;
> atomic_long_t lruvec_stat[NR_VM_NODE_STAT_ITEMS];
>
> unsigned long lru_zone_size[5][NR_LRU_LISTS];
>
> struct mem_cgroup_reclaim_iter iter;
>
> struct shrinker_info *shrinker_info;
>
> struct rb_node tree_node;
> unsigned long usage_in_excess;
>
> bool on_tree;
> struct mem_cgroup *memcg;
>
>};
>
>struct mem_cgroup_threshold {
> struct eventfd_ctx *eventfd;
> unsigned long threshold;
>};
>
>
>struct mem_cgroup_threshold_ary {
>
> int current_threshold;
>
> unsigned int size;
>
> struct mem_cgroup_threshold entries[];
>};
>
>struct mem_cgroup_thresholds {
>
> struct mem_cgroup_threshold_ary *primary;
>
>
>
>
>
> struct mem_cgroup_threshold_ary *spare;
>};
>
>enum memcg_kmem_state {
> KMEM_NONE,
> KMEM_ALLOCATED,
> KMEM_ONLINE,
>};
>
>
>struct memcg_padding {
> char x[0];
>} __attribute__((__aligned__(1 << (6))));
># 210 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>struct memcg_cgwb_frn {
> u64 bdi_id;
> int memcg_id;
> u64 at;
> struct wb_completion done;
>};
>
>
>
>
>
>
>
>struct obj_cgroup {
> struct percpu_ref refcnt;
> struct mem_cgroup *memcg;
> atomic_t nr_charged_bytes;
> union {
>  struct list_head list;
>  struct callback_head rcu;
> };
>};
>
>
>
>
>
>
>
>struct mem_cgroup {
> struct cgroup_subsys_state css;
>
>
> struct mem_cgroup_id id;
>
>
> struct page_counter memory;
>
> union {
>  struct page_counter swap;
>  struct page_counter memsw;
> };
>
>
> struct page_counter kmem;
> struct page_counter tcpmem;
>
>
> struct work_struct high_work;
>
> unsigned long soft_limit;
>
>
> struct vmpressure vmpressure;
>
>
>
>
> bool oom_group;
>
>
> bool oom_lock;
> int under_oom;
>
> int swappiness;
>
> int oom_kill_disable;
>
>
> struct cgroup_file events_file;
> struct cgroup_file events_local_file;
>
>
> struct cgroup_file swap_events_file;
>
>
> struct mutex thresholds_lock;
>
>
> struct mem_cgroup_thresholds thresholds;
>
>
> struct mem_cgroup_thresholds memsw_thresholds;
>
>
> struct list_head oom_notify;
>
>
>
>
>
> unsigned long move_charge_at_immigrate;
>
> spinlock_t move_lock;
> unsigned long move_lock_flags;
>
> struct memcg_padding _pad1_;
>
>
> struct memcg_vmstats vmstats;
>
>
> atomic_long_t memory_events[MEMCG_NR_MEMORY_EVENTS];
> atomic_long_t memory_events_local[MEMCG_NR_MEMORY_EVENTS];
>
> unsigned long socket_pressure;
>
>
> bool tcpmem_active;
> int tcpmem_pressure;
>
>
> int kmemcg_id;
> enum memcg_kmem_state kmem_state;
> struct obj_cgroup *objcg;
>
> struct list_head objcg_list;
>
>
> struct memcg_padding _pad2_;
>
>
>
>
> atomic_t moving_account;
> struct task_struct *move_lock_task;
>
> struct memcg_vmstats_percpu *vmstats_percpu;
>
>
> struct list_head cgwb_list;
> struct wb_domain cgwb_domain;
> struct memcg_cgwb_frn cgwb_frn[4];
>
>
>
> struct list_head event_list;
> spinlock_t event_list_lock;
>
>
> struct deferred_split deferred_split_queue;
>
>
> struct mem_cgroup_per_node *nodeinfo[];
>};
>
>
>
>
>
>
>
>extern struct mem_cgroup *root_mem_cgroup;
>
>enum page_memcg_data_flags {
>
> MEMCG_DATA_OBJCGS = (1UL << 0),
>
> MEMCG_DATA_KMEM = (1UL << 1),
>
> __NR_MEMCG_DATA_FLAGS = (1UL << 2),
>};
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool PageMemcgKmem(struct page *page);
># 384 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *obj_cgroup_memcg(struct obj_cgroup *objcg)
>{
> return ({ do { extern void __compiletime_assert_340(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(objcg->memcg) == sizeof(char) || sizeof(objcg->memcg) == sizeof(short) || sizeof(objcg->memcg) == sizeof(int) || sizeof(objcg->memcg) == sizeof(long)) || sizeof(objcg->memcg) == sizeof(long long))) __compiletime_assert_340(); } while (0); (*(const volatile typeof( _Generic((objcg->memcg), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (objcg->memcg))) *)&(objcg->memcg)); });
>}
># 399 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *__page_memcg(struct page *page)
>{
> unsigned long memcg_data = page->memcg_data;
>
> ((void)(sizeof(( long)(PageSlab(page)))));
> ((void)(sizeof(( long)(memcg_data & MEMCG_DATA_OBJCGS))));
> ((void)(sizeof(( long)(memcg_data & MEMCG_DATA_KMEM))));
>
> return (struct mem_cgroup *)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>}
># 420 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct obj_cgroup *__page_objcg(struct page *page)
>{
> unsigned long memcg_data = page->memcg_data;
>
> ((void)(sizeof(( long)(PageSlab(page)))));
> ((void)(sizeof(( long)(memcg_data & MEMCG_DATA_OBJCGS))));
> ((void)(sizeof(( long)(!(memcg_data & MEMCG_DATA_KMEM)))));
>
> return (struct obj_cgroup *)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>}
># 451 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *page_memcg(struct page *page)
>{
> if (PageMemcgKmem(page))
>  return obj_cgroup_memcg(__page_objcg(page));
> else
>  return __page_memcg(page);
>}
># 468 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *page_memcg_rcu(struct page *page)
>{
> unsigned long memcg_data = ({ do { extern void __compiletime_assert_341(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->memcg_data) == sizeof(char) || sizeof(page->memcg_data) == sizeof(short) || sizeof(page->memcg_data) == sizeof(int) || sizeof(page->memcg_data) == sizeof(long)) || sizeof(page->memcg_data) == sizeof(long long))) __compiletime_assert_341(); } while (0); (*(const volatile typeof( _Generic((page->memcg_data), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (page->memcg_data))) *)&(page->memcg_data)); });
>
> ((void)(sizeof(( long)(PageSlab(page)))));
> ({ int __ret_warn_on = !!(!rcu_read_lock_held()); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"), "i" (473), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("342" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "342" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>
> if (memcg_data & MEMCG_DATA_KMEM) {
>  struct obj_cgroup *objcg;
>
>  objcg = (void *)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>  return obj_cgroup_memcg(objcg);
> }
>
> return (struct mem_cgroup *)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>}
># 506 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *page_memcg_check(struct page *page)
>{
>
>
>
>
> unsigned long memcg_data = ({ do { extern void __compiletime_assert_343(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->memcg_data) == sizeof(char) || sizeof(page->memcg_data) == sizeof(short) || sizeof(page->memcg_data) == sizeof(int) || sizeof(page->memcg_data) == sizeof(long)) || sizeof(page->memcg_data) == sizeof(long long))) __compiletime_assert_343(); } while (0); (*(const volatile typeof( _Generic((page->memcg_data), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (page->memcg_data))) *)&(page->memcg_data)); });
>
> if (memcg_data & MEMCG_DATA_OBJCGS)
>  return ((void *)0);
>
> if (memcg_data & MEMCG_DATA_KMEM) {
>  struct obj_cgroup *objcg;
>
>  objcg = (void *)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>  return obj_cgroup_memcg(objcg);
> }
>
> return (struct mem_cgroup *)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>}
># 536 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool PageMemcgKmem(struct page *page)
>{
> ((void)(sizeof(( long)(page->memcg_data & MEMCG_DATA_OBJCGS))));
> return page->memcg_data & MEMCG_DATA_KMEM;
>}
># 552 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct obj_cgroup **page_objcgs(struct page *page)
>{
> unsigned long memcg_data = ({ do { extern void __compiletime_assert_344(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->memcg_data) == sizeof(char) || sizeof(page->memcg_data) == sizeof(short) || sizeof(page->memcg_data) == sizeof(int) || sizeof(page->memcg_data) == sizeof(long)) || sizeof(page->memcg_data) == sizeof(long long))) __compiletime_assert_344(); } while (0); (*(const volatile typeof( _Generic((page->memcg_data), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (page->memcg_data))) *)&(page->memcg_data)); });
>
> ((void)(sizeof(( long)(memcg_data && !(memcg_data & MEMCG_DATA_OBJCGS)))));
> ((void)(sizeof(( long)(memcg_data & MEMCG_DATA_KMEM))));
>
> return (struct obj_cgroup **)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>}
># 570 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct obj_cgroup **page_objcgs_check(struct page *page)
>{
> unsigned long memcg_data = ({ do { extern void __compiletime_assert_345(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(page->memcg_data) == sizeof(char) || sizeof(page->memcg_data) == sizeof(short) || sizeof(page->memcg_data) == sizeof(int) || sizeof(page->memcg_data) == sizeof(long)) || sizeof(page->memcg_data) == sizeof(long long))) __compiletime_assert_345(); } while (0); (*(const volatile typeof( _Generic((page->memcg_data), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (page->memcg_data))) *)&(page->memcg_data)); });
>
> if (!memcg_data || !(memcg_data & MEMCG_DATA_OBJCGS))
>  return ((void *)0);
>
> ((void)(sizeof(( long)(memcg_data & MEMCG_DATA_KMEM))));
>
> return (struct obj_cgroup **)(memcg_data & ~(__NR_MEMCG_DATA_FLAGS - 1));
>}
># 599 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool memcg_stat_item_in_bytes(int idx)
>{
> if (idx == MEMCG_PERCPU_B)
>  return true;
> return vmstat_item_in_bytes(idx);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_is_root(struct mem_cgroup *memcg)
>{
> return (memcg == root_mem_cgroup);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_disabled(void)
>{
> return !({ bool branch; if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_enabled_key), struct static_key_true)) branch = !arch_static_branch(&(&memory_cgrp_subsys_enabled_key)->key, true); else if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_enabled_key), struct static_key_false)) branch = !arch_static_branch_jump(&(&memory_cgrp_subsys_enabled_key)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_protection(struct mem_cgroup *root,
>      struct mem_cgroup *memcg,
>      unsigned long *min,
>      unsigned long *low)
>{
> *min = *low = 0;
>
> if (mem_cgroup_disabled())
>  return;
># 659 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
> if (root == memcg)
>  return;
>
> *min = ({ do { extern void __compiletime_assert_346(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(memcg->memory.emin) == sizeof(char) || sizeof(memcg->memory.emin) == sizeof(short) || sizeof(memcg->memory.emin) == sizeof(int) || sizeof(memcg->memory.emin) == sizeof(long)) || sizeof(memcg->memory.emin) == sizeof(long long))) __compiletime_assert_346(); } while (0); (*(const volatile typeof( _Generic((memcg->memory.emin), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (memcg->memory.emin))) *)&(memcg->memory.emin)); });
> *low = ({ do { extern void __compiletime_assert_347(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(memcg->memory.elow) == sizeof(char) || sizeof(memcg->memory.elow) == sizeof(short) || sizeof(memcg->memory.elow) == sizeof(int) || sizeof(memcg->memory.elow) == sizeof(long)) || sizeof(memcg->memory.elow) == sizeof(long long))) __compiletime_assert_347(); } while (0); (*(const volatile typeof( _Generic((memcg->memory.elow), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (memcg->memory.elow))) *)&(memcg->memory.elow)); });
>}
>
>void mem_cgroup_calculate_protection(struct mem_cgroup *root,
>         struct mem_cgroup *memcg);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_supports_protection(struct mem_cgroup *memcg)
>{
>
>
>
>
> return !mem_cgroup_disabled() && !mem_cgroup_is_root(memcg);
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_below_low(struct mem_cgroup *memcg)
>{
> if (!mem_cgroup_supports_protection(memcg))
>  return false;
>
> return ({ do { extern void __compiletime_assert_348(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(memcg->memory.elow) == sizeof(char) || sizeof(memcg->memory.elow) == sizeof(short) || sizeof(memcg->memory.elow) == sizeof(int) || sizeof(memcg->memory.elow) == sizeof(long)) || sizeof(memcg->memory.elow) == sizeof(long long))) __compiletime_assert_348(); } while (0); (*(const volatile typeof( _Generic((memcg->memory.elow), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (memcg->memory.elow))) *)&(memcg->memory.elow)); }) >=
>  page_counter_read(&memcg->memory);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_below_min(struct mem_cgroup *memcg)
>{
> if (!mem_cgroup_supports_protection(memcg))
>  return false;
>
> return ({ do { extern void __compiletime_assert_349(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(memcg->memory.emin) == sizeof(char) || sizeof(memcg->memory.emin) == sizeof(short) || sizeof(memcg->memory.emin) == sizeof(int) || sizeof(memcg->memory.emin) == sizeof(long)) || sizeof(memcg->memory.emin) == sizeof(long long))) __compiletime_assert_349(); } while (0); (*(const volatile typeof( _Generic((memcg->memory.emin), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (memcg->memory.emin))) *)&(memcg->memory.emin)); }) >=
>  page_counter_read(&memcg->memory);
>}
>
>int __mem_cgroup_charge(struct page *page, struct mm_struct *mm,
>   gfp_t gfp_mask);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mem_cgroup_charge(struct page *page, struct mm_struct *mm,
>        gfp_t gfp_mask)
>{
> if (mem_cgroup_disabled())
>  return 0;
> return __mem_cgroup_charge(page, mm, gfp_mask);
>}
>
>int mem_cgroup_swapin_charge_page(struct page *page, struct mm_struct *mm,
>      gfp_t gfp, swp_entry_t entry);
>void mem_cgroup_swapin_uncharge_swap(swp_entry_t entry);
>
>void __mem_cgroup_uncharge(struct page *page);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_uncharge(struct page *page)
>{
> if (mem_cgroup_disabled())
>  return;
> __mem_cgroup_uncharge(page);
>}
>
>void __mem_cgroup_uncharge_list(struct list_head *page_list);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_uncharge_list(struct list_head *page_list)
>{
> if (mem_cgroup_disabled())
>  return;
> __mem_cgroup_uncharge_list(page_list);
>}
>
>void mem_cgroup_migrate(struct page *oldpage, struct page *newpage);
># 738 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct lruvec *mem_cgroup_lruvec(struct mem_cgroup *memcg,
>            struct pglist_data *pgdat)
>{
> struct mem_cgroup_per_node *mz;
> struct lruvec *lruvec;
>
> if (mem_cgroup_disabled()) {
>  lruvec = &pgdat->__lruvec;
>  goto out;
> }
>
> if (!memcg)
>  memcg = root_mem_cgroup;
>
> mz = memcg->nodeinfo[pgdat->node_id];
> lruvec = &mz->lruvec;
>out:
>
>
>
>
>
> if (__builtin_expect(!!(lruvec->pgdat != pgdat), 0))
>  lruvec->pgdat = pgdat;
> return lruvec;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct lruvec *mem_cgroup_page_lruvec(struct page *page)
>{
> pg_data_t *pgdat = page_pgdat(page);
> struct mem_cgroup *memcg = page_memcg(page);
>
> ((void)(sizeof(( long)(!memcg && !mem_cgroup_disabled()))));
> return mem_cgroup_lruvec(memcg, pgdat);
>}
>
>struct mem_cgroup *mem_cgroup_from_task(struct task_struct *p);
>
>struct mem_cgroup *get_mem_cgroup_from_mm(struct mm_struct *mm);
>
>struct lruvec *lock_page_lruvec(struct page *page);
>struct lruvec *lock_page_lruvec_irq(struct page *page);
>struct lruvec *lock_page_lruvec_irqsave(struct page *page,
>      unsigned long *flags);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lruvec_memcg_debug(struct lruvec *lruvec, struct page *page)
>{
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>struct mem_cgroup *mem_cgroup_from_css(struct cgroup_subsys_state *css){
> return css ? ({ void *__mptr = (void *)(css); do { extern void __compiletime_assert_350(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(css)), typeof(((struct mem_cgroup *)0)->css)) && !__builtin_types_compatible_p(typeof(*(css)), typeof(void))))) __compiletime_assert_350(); } while (0); ((struct mem_cgroup *)(__mptr - __builtin_offsetof(struct mem_cgroup, css))); }) : ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool obj_cgroup_tryget(struct obj_cgroup *objcg)
>{
> return percpu_ref_tryget(&objcg->refcnt);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void obj_cgroup_get(struct obj_cgroup *objcg)
>{
> percpu_ref_get(&objcg->refcnt);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void obj_cgroup_get_many(struct obj_cgroup *objcg,
>           unsigned long nr)
>{
> percpu_ref_get_many(&objcg->refcnt, nr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void obj_cgroup_put(struct obj_cgroup *objcg)
>{
> percpu_ref_put(&objcg->refcnt);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_put(struct mem_cgroup *memcg)
>{
> if (memcg)
>  css_put(&memcg->css);
>}
>
>
>
>
>struct mem_cgroup *mem_cgroup_iter(struct mem_cgroup *,
>       struct mem_cgroup *,
>       struct mem_cgroup_reclaim_cookie *);
>void mem_cgroup_iter_break(struct mem_cgroup *, struct mem_cgroup *);
>int mem_cgroup_scan_tasks(struct mem_cgroup *,
>     int (*)(struct task_struct *, void *), void *);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned short mem_cgroup_id(struct mem_cgroup *memcg)
>{
> if (mem_cgroup_disabled())
>  return 0;
>
> return memcg->id.id;
>}
>struct mem_cgroup *mem_cgroup_from_id(unsigned short id);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *mem_cgroup_from_seq(struct seq_file *m)
>{
> return mem_cgroup_from_css(seq_css(m));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *lruvec_memcg(struct lruvec *lruvec)
>{
> struct mem_cgroup_per_node *mz;
>
> if (mem_cgroup_disabled())
>  return ((void *)0);
>
> mz = ({ void *__mptr = (void *)(lruvec); do { extern void __compiletime_assert_351(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(lruvec)), typeof(((struct mem_cgroup_per_node *)0)->lruvec)) && !__builtin_types_compatible_p(typeof(*(lruvec)), typeof(void))))) __compiletime_assert_351(); } while (0); ((struct mem_cgroup_per_node *)(__mptr - __builtin_offsetof(struct mem_cgroup_per_node, lruvec))); });
> return mz->memcg;
>}
># 871 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct mem_cgroup *parent_mem_cgroup(struct mem_cgroup *memcg)
>{
> if (!memcg->memory.parent)
>  return ((void *)0);
> return ({ void *__mptr = (void *)(memcg->memory.parent); do { extern void __compiletime_assert_352(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(memcg->memory.parent)), typeof(((struct mem_cgroup *)0)->memory)) && !__builtin_types_compatible_p(typeof(*(memcg->memory.parent)), typeof(void))))) __compiletime_assert_352(); } while (0); ((struct mem_cgroup *)(__mptr - __builtin_offsetof(struct mem_cgroup, memory))); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_is_descendant(struct mem_cgroup *memcg,
>         struct mem_cgroup *root)
>{
> if (root == memcg)
>  return true;
> return cgroup_is_descendant(memcg->css.cgroup, root->css.cgroup);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mm_match_cgroup(struct mm_struct *mm,
>       struct mem_cgroup *memcg)
>{
> struct mem_cgroup *task_memcg;
> bool match = false;
>
> rcu_read_lock();
> task_memcg = mem_cgroup_from_task(({ typeof(*(mm->owner)) *________p1 = (typeof(*(mm->owner)) *)({ do { extern void __compiletime_assert_353(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((mm->owner)) == sizeof(char) || sizeof((mm->owner)) == sizeof(short) || sizeof((mm->owner)) == sizeof(int) || sizeof((mm->owner)) == sizeof(long)) || sizeof((mm->owner)) == sizeof(long long))) __compiletime_assert_353(); } while (0); (*(const volatile typeof( _Generic(((mm->owner)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((mm->owner)))) *)&((mm->owner))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(mm->owner)) *)(________p1)); }));
> if (task_memcg)
>  match = mem_cgroup_is_descendant(task_memcg, memcg);
> rcu_read_unlock();
> return match;
>}
>
>struct cgroup_subsys_state *mem_cgroup_css_from_page(struct page *page);
>ino_t page_cgroup_ino(struct page *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_online(struct mem_cgroup *memcg)
>{
> if (mem_cgroup_disabled())
>  return true;
> return !!(memcg->css.flags & CSS_ONLINE);
>}
>
>
>
>
>int mem_cgroup_select_victim_node(struct mem_cgroup *memcg);
>
>void mem_cgroup_update_lru_size(struct lruvec *lruvec, enum lru_list lru,
>  int zid, int nr_pages);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function))
>unsigned long mem_cgroup_get_zone_lru_size(struct lruvec *lruvec,
>  enum lru_list lru, int zone_idx)
>{
> struct mem_cgroup_per_node *mz;
>
> mz = ({ void *__mptr = (void *)(lruvec); do { extern void __compiletime_assert_354(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(lruvec)), typeof(((struct mem_cgroup_per_node *)0)->lruvec)) && !__builtin_types_compatible_p(typeof(*(lruvec)), typeof(void))))) __compiletime_assert_354(); } while (0); ((struct mem_cgroup_per_node *)(__mptr - __builtin_offsetof(struct mem_cgroup_per_node, lruvec))); });
> return ({ do { extern void __compiletime_assert_355(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(mz->lru_zone_size[zone_idx][lru]) == sizeof(char) || sizeof(mz->lru_zone_size[zone_idx][lru]) == sizeof(short) || sizeof(mz->lru_zone_size[zone_idx][lru]) == sizeof(int) || sizeof(mz->lru_zone_size[zone_idx][lru]) == sizeof(long)) || sizeof(mz->lru_zone_size[zone_idx][lru]) == sizeof(long long))) __compiletime_assert_355(); } while (0); (*(const volatile typeof( _Generic((mz->lru_zone_size[zone_idx][lru]), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (mz->lru_zone_size[zone_idx][lru]))) *)&(mz->lru_zone_size[zone_idx][lru])); });
>}
>
>void mem_cgroup_handle_over_high(void);
>
>unsigned long mem_cgroup_get_max(struct mem_cgroup *memcg);
>
>unsigned long mem_cgroup_size(struct mem_cgroup *memcg);
>
>void mem_cgroup_print_oom_context(struct mem_cgroup *memcg,
>    struct task_struct *p);
>
>void mem_cgroup_print_oom_meminfo(struct mem_cgroup *memcg);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_enter_user_fault(void)
>{
> ({ int __ret_warn_on = !!(get_current()->in_user_fault); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"), "i" (941), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("356" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "356" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> get_current()->in_user_fault = 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_exit_user_fault(void)
>{
> ({ int __ret_warn_on = !!(!get_current()->in_user_fault); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"), "i" (947), "i" ((1 << 0)|(((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("357" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "357" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> get_current()->in_user_fault = 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool task_in_memcg_oom(struct task_struct *p)
>{
> return p->memcg_in_oom;
>}
>
>bool mem_cgroup_oom_synchronize(bool wait);
>struct mem_cgroup *mem_cgroup_get_oom_group(struct task_struct *victim,
>         struct mem_cgroup *oom_domain);
>void mem_cgroup_print_oom_group(struct mem_cgroup *memcg);
>
>
>extern bool cgroup_memory_noswap;
>
>
>void lock_page_memcg(struct page *page);
>void unlock_page_memcg(struct page *page);
>
>void __mod_memcg_state(struct mem_cgroup *memcg, int idx, int val);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mod_memcg_state(struct mem_cgroup *memcg,
>       int idx, int val)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __mod_memcg_state(memcg, idx, val);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long lruvec_page_state(struct lruvec *lruvec,
>           enum node_stat_item idx)
>{
> struct mem_cgroup_per_node *pn;
> long x;
>
> if (mem_cgroup_disabled())
>  return node_page_state(lruvec_pgdat(lruvec), idx);
>
> pn = ({ void *__mptr = (void *)(lruvec); do { extern void __compiletime_assert_358(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(lruvec)), typeof(((struct mem_cgroup_per_node *)0)->lruvec)) && !__builtin_types_compatible_p(typeof(*(lruvec)), typeof(void))))) __compiletime_assert_358(); } while (0); ((struct mem_cgroup_per_node *)(__mptr - __builtin_offsetof(struct mem_cgroup_per_node, lruvec))); });
> x = atomic_long_read(&pn->lruvec_stat[idx]);
>
> if (x < 0)
>  x = 0;
>
> return x;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long lruvec_page_state_local(struct lruvec *lruvec,
>          enum node_stat_item idx)
>{
> struct mem_cgroup_per_node *pn;
> long x = 0;
> int cpu;
>
> if (mem_cgroup_disabled())
>  return node_page_state(lruvec_pgdat(lruvec), idx);
>
> pn = ({ void *__mptr = (void *)(lruvec); do { extern void __compiletime_assert_359(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(lruvec)), typeof(((struct mem_cgroup_per_node *)0)->lruvec)) && !__builtin_types_compatible_p(typeof(*(lruvec)), typeof(void))))) __compiletime_assert_359(); } while (0); ((struct mem_cgroup_per_node *)(__mptr - __builtin_offsetof(struct mem_cgroup_per_node, lruvec))); });
> for (((cpu)) = -1; ((cpu)) = cpumask_next(((cpu)), (((const struct cpumask *)&__cpu_possible_mask))), ((cpu)) < nr_cpu_ids;)
>  x += (*({ do { const void *__vpp_verify = (typeof((&(pn->lruvec_stat_local->count[idx])) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long __ptr; __asm__ ("" : "=r"(__ptr) : "0"((typeof(*((&(pn->lruvec_stat_local->count[idx])))) *)((&(pn->lruvec_stat_local->count[idx]))))); (typeof((typeof(*((&(pn->lruvec_stat_local->count[idx])))) *)((&(pn->lruvec_stat_local->count[idx]))))) (__ptr + (((__per_cpu_offset[(cpu)])))); }); }));
>
> if (x < 0)
>  x = 0;
>
> return x;
>}
>
>void __mod_memcg_lruvec_state(struct lruvec *lruvec, enum node_stat_item idx,
>         int val);
>void __mod_lruvec_kmem_state(void *p, enum node_stat_item idx, int val);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mod_lruvec_kmem_state(void *p, enum node_stat_item idx,
>      int val)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __mod_lruvec_kmem_state(p, idx, val);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mod_memcg_lruvec_state(struct lruvec *lruvec,
>       enum node_stat_item idx, int val)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __mod_memcg_lruvec_state(lruvec, idx, val);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>void __count_memcg_events(struct mem_cgroup *memcg, enum vm_event_item idx,
>     unsigned long count);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void count_memcg_events(struct mem_cgroup *memcg,
>          enum vm_event_item idx,
>          unsigned long count)
>{
> unsigned long flags;
>
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); flags = arch_local_irq_save(); } while (0); } while (0);
> __count_memcg_events(memcg, idx, count);
> do { do { ({ unsigned long __dummy; typeof(flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); do { } while (0); arch_local_irq_restore(flags); } while (0); } while (0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void count_memcg_page_event(struct page *page,
>       enum vm_event_item idx)
>{
> struct mem_cgroup *memcg = page_memcg(page);
>
> if (memcg)
>  count_memcg_events(memcg, idx, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void count_memcg_event_mm(struct mm_struct *mm,
>     enum vm_event_item idx)
>{
> struct mem_cgroup *memcg;
>
> if (mem_cgroup_disabled())
>  return;
>
> rcu_read_lock();
> memcg = mem_cgroup_from_task(({ typeof(*(mm->owner)) *________p1 = (typeof(*(mm->owner)) *)({ do { extern void __compiletime_assert_360(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((mm->owner)) == sizeof(char) || sizeof((mm->owner)) == sizeof(short) || sizeof((mm->owner)) == sizeof(int) || sizeof((mm->owner)) == sizeof(long)) || sizeof((mm->owner)) == sizeof(long long))) __compiletime_assert_360(); } while (0); (*(const volatile typeof( _Generic(((mm->owner)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((mm->owner)))) *)&((mm->owner))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(mm->owner)) *)(________p1)); }));
> if (__builtin_expect(!!(memcg), 1))
>  count_memcg_events(memcg, idx, 1);
> rcu_read_unlock();
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcg_memory_event(struct mem_cgroup *memcg,
>          enum memcg_memory_event event)
>{
> bool swap_event = event == MEMCG_SWAP_HIGH || event == MEMCG_SWAP_MAX ||
>     event == MEMCG_SWAP_FAIL;
>
> atomic_long_inc(&memcg->memory_events_local[event]);
> if (!swap_event)
>  cgroup_file_notify(&memcg->events_local_file);
>
> do {
>  atomic_long_inc(&memcg->memory_events[event]);
>  if (swap_event)
>   cgroup_file_notify(&memcg->swap_events_file);
>  else
>   cgroup_file_notify(&memcg->events_file);
>
>  if (!({ bool branch; if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_on_dfl_key), struct static_key_true)) branch = !arch_static_branch(&(&memory_cgrp_subsys_on_dfl_key)->key, true); else if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_on_dfl_key), struct static_key_false)) branch = !arch_static_branch_jump(&(&memory_cgrp_subsys_on_dfl_key)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }))
>   break;
>  if (cgrp_dfl_root.flags & CGRP_ROOT_MEMORY_LOCAL_EVENTS)
>   break;
> } while ((memcg = parent_mem_cgroup(memcg)) &&
>   !mem_cgroup_is_root(memcg));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcg_memory_event_mm(struct mm_struct *mm,
>      enum memcg_memory_event event)
>{
> struct mem_cgroup *memcg;
>
> if (mem_cgroup_disabled())
>  return;
>
> rcu_read_lock();
> memcg = mem_cgroup_from_task(({ typeof(*(mm->owner)) *________p1 = (typeof(*(mm->owner)) *)({ do { extern void __compiletime_assert_361(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((mm->owner)) == sizeof(char) || sizeof((mm->owner)) == sizeof(short) || sizeof((mm->owner)) == sizeof(int) || sizeof((mm->owner)) == sizeof(long)) || sizeof((mm->owner)) == sizeof(long long))) __compiletime_assert_361(); } while (0); (*(const volatile typeof( _Generic(((mm->owner)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((mm->owner)))) *)&((mm->owner))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(mm->owner)) *)(________p1)); }));
> if (__builtin_expect(!!(memcg), 1))
>  memcg_memory_event(memcg, event);
> rcu_read_unlock();
>}
>
>void split_page_memcg(struct page *head, unsigned int nr);
>
>unsigned long mem_cgroup_soft_limit_reclaim(pg_data_t *pgdat, int order,
>      gfp_t gfp_mask,
>      unsigned long *total_scanned);
># 1485 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __inc_lruvec_kmem_state(void *p, enum node_stat_item idx)
>{
> __mod_lruvec_kmem_state(p, idx, 1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __dec_lruvec_kmem_state(void *p, enum node_stat_item idx)
>{
> __mod_lruvec_kmem_state(p, idx, -1);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct lruvec *parent_lruvec(struct lruvec *lruvec)
>{
> struct mem_cgroup *memcg;
>
> memcg = lruvec_memcg(lruvec);
> if (!memcg)
>  return ((void *)0);
> memcg = parent_mem_cgroup(memcg);
> if (!memcg)
>  return ((void *)0);
> return mem_cgroup_lruvec(memcg, lruvec_pgdat(lruvec));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unlock_page_lruvec(struct lruvec *lruvec)
>{
> spin_unlock(&lruvec->lru_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unlock_page_lruvec_irq(struct lruvec *lruvec)
>{
> spin_unlock_irq(&lruvec->lru_lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unlock_page_lruvec_irqrestore(struct lruvec *lruvec,
>  unsigned long flags)
>{
> spin_unlock_irqrestore(&lruvec->lru_lock, flags);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool page_matches_lruvec(struct page *page, struct lruvec *lruvec)
>{
> return lruvec_pgdat(lruvec) == page_pgdat(page) &&
>        lruvec_memcg(lruvec) == page_memcg(page);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct lruvec *relock_page_lruvec_irq(struct page *page,
>  struct lruvec *locked_lruvec)
>{
> if (locked_lruvec) {
>  if (page_matches_lruvec(page, locked_lruvec))
>   return locked_lruvec;
>
>  unlock_page_lruvec_irq(locked_lruvec);
> }
>
> return lock_page_lruvec_irq(page);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct lruvec *relock_page_lruvec_irqsave(struct page *page,
>  struct lruvec *locked_lruvec, unsigned long *flags)
>{
> if (locked_lruvec) {
>  if (page_matches_lruvec(page, locked_lruvec))
>   return locked_lruvec;
>
>  unlock_page_lruvec_irqrestore(locked_lruvec, *flags);
> }
>
> return lock_page_lruvec_irqsave(page, flags);
>}
>
>
>
>struct wb_domain *mem_cgroup_wb_domain(struct bdi_writeback *wb);
>void mem_cgroup_wb_stats(struct bdi_writeback *wb, unsigned long *pfilepages,
>    unsigned long *pheadroom, unsigned long *pdirty,
>    unsigned long *pwriteback);
>
>void mem_cgroup_track_foreign_dirty_slowpath(struct page *page,
>          struct bdi_writeback *wb);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_track_foreign_dirty(struct page *page,
>        struct bdi_writeback *wb)
>{
> if (mem_cgroup_disabled())
>  return;
>
> if (__builtin_expect(!!(&page_memcg(page)->css != wb->memcg_css), 0))
>  mem_cgroup_track_foreign_dirty_slowpath(page, wb);
>}
>
>void mem_cgroup_flush_foreign(struct bdi_writeback *wb);
># 1607 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>struct sock;
>bool mem_cgroup_charge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
>void mem_cgroup_uncharge_skmem(struct mem_cgroup *memcg, unsigned int nr_pages);
>
>extern struct static_key_false memcg_sockets_enabled_key;
>
>void mem_cgroup_sk_alloc(struct sock *sk);
>void mem_cgroup_sk_free(struct sock *sk);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool mem_cgroup_under_socket_pressure(struct mem_cgroup *memcg)
>{
> if (!({ bool branch; if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_on_dfl_key), struct static_key_true)) branch = !arch_static_branch(&(&memory_cgrp_subsys_on_dfl_key)->key, true); else if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_on_dfl_key), struct static_key_false)) branch = !arch_static_branch_jump(&(&memory_cgrp_subsys_on_dfl_key)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }) && memcg->tcpmem_pressure)
>  return true;
> do {
>  if ((({ unsigned long __dummy; typeof(memcg->socket_pressure) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ({ unsigned long __dummy; typeof(jiffies) __dummy2; (void)(&__dummy == &__dummy2); 1; }) && ((long)((jiffies) - (memcg->socket_pressure)) < 0)))
>   return true;
> } while ((memcg = parent_mem_cgroup(memcg)));
> return false;
>}
>
>int alloc_shrinker_info(struct mem_cgroup *memcg);
>void free_shrinker_info(struct mem_cgroup *memcg);
>void set_shrinker_bit(struct mem_cgroup *memcg, int nid, int shrinker_id);
>void reparent_shrinker_deferred(struct mem_cgroup *memcg);
># 1646 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>bool mem_cgroup_kmem_disabled(void);
>int __memcg_kmem_charge_page(struct page *page, gfp_t gfp, int order);
>void __memcg_kmem_uncharge_page(struct page *page, int order);
>
>struct obj_cgroup *get_obj_cgroup_from_current(void);
>
>int obj_cgroup_charge(struct obj_cgroup *objcg, gfp_t gfp, size_t size);
>void obj_cgroup_uncharge(struct obj_cgroup *objcg, size_t size);
>
>extern struct static_key_false memcg_kmem_enabled_key;
>
>extern int memcg_nr_cache_ids;
>void memcg_get_cache_ids(void);
>void memcg_put_cache_ids(void);
># 1669 "/usr/src/linux-5.14.21-150500.53/include/linux/memcontrol.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool memcg_kmem_enabled(void)
>{
> return ({ bool branch; if (__builtin_types_compatible_p(typeof(*&memcg_kmem_enabled_key), struct static_key_true)) branch = !arch_static_branch(&(&memcg_kmem_enabled_key)->key, true); else if (__builtin_types_compatible_p(typeof(*&memcg_kmem_enabled_key), struct static_key_false)) branch = !arch_static_branch_jump(&(&memcg_kmem_enabled_key)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int memcg_kmem_charge_page(struct page *page, gfp_t gfp,
>      int order)
>{
> if (memcg_kmem_enabled())
>  return __memcg_kmem_charge_page(page, gfp, order);
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void memcg_kmem_uncharge_page(struct page *page, int order)
>{
> if (memcg_kmem_enabled())
>  __memcg_kmem_uncharge_page(page, order);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int memcg_cache_id(struct mem_cgroup *memcg)
>{
> return memcg ? memcg->kmemcg_id : -1;
>}
>
>struct mem_cgroup *mem_cgroup_from_obj(void *p);
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h" 2
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/mempolicy.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/mempolicy.h"
>enum {
> MPOL_DEFAULT,
> MPOL_PREFERRED,
> MPOL_BIND,
> MPOL_INTERLEAVE,
> MPOL_LOCAL,
> MPOL_PREFERRED_MANY,
> MPOL_MAX,
>};
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h" 2
>
>
>struct notifier_block;
>
>struct bio;
>
>struct pagevec;
># 37 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int current_is_kswapd(void)
>{
> return get_current()->flags & 0x00020000;
>}
># 117 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>union swap_header {
> struct {
>  char reserved[((1UL) << 12) - 10];
>  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 reclaim_state {
> unsigned long reclaimed_slab;
>};
>
>
>
>struct address_space;
>struct sysinfo;
>struct writeback_control;
>struct zone;
># 157 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>struct swap_extent {
> struct rb_node rb_node;
> unsigned long start_page;
> unsigned long nr_pages;
> sector_t start_block;
>};
># 171 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>enum {
> SWP_USED = (1 << 0),
> SWP_WRITEOK = (1 << 1),
> SWP_DISCARDABLE = (1 << 2),
> SWP_DISCARDING = (1 << 3),
> SWP_SOLIDSTATE = (1 << 4),
> SWP_CONTINUED = (1 << 5),
> SWP_BLKDEV = (1 << 6),
> SWP_ACTIVATED = (1 << 7),
> SWP_FS_OPS = (1 << 8),
> SWP_AREA_DISCARD = (1 << 9),
> SWP_PAGE_DISCARD = (1 << 10),
> SWP_STABLE_WRITES = (1 << 11),
> SWP_SYNCHRONOUS_IO = (1 << 12),
>
> SWP_SCANNING = (1 << 14),
>};
># 214 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>struct swap_cluster_info {
> spinlock_t lock;
>
>
>
>
>
> unsigned int data:24;
> unsigned int flags:8;
>};
># 233 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>struct percpu_cluster {
> struct swap_cluster_info index;
> unsigned int next;
>};
>
>struct swap_cluster_list {
> struct swap_cluster_info head;
> struct swap_cluster_info tail;
>};
>
>
>
>
>struct swap_info_struct {
> struct percpu_ref users;
> unsigned long flags;
> signed short prio;
> struct plist_node list;
> signed char type;
> unsigned int max;
> unsigned char *swap_map;
> struct swap_cluster_info *cluster_info;
> struct swap_cluster_list free_clusters;
> unsigned int lowest_bit;
> unsigned int highest_bit;
> unsigned int pages;
> unsigned int inuse_pages;
> unsigned int cluster_next;
> unsigned int cluster_nr;
> unsigned int *cluster_next_cpu;
> struct percpu_cluster *percpu_cluster;
> struct rb_root swap_extent_root;
> struct block_device *bdev;
> struct file *swap_file;
> unsigned int old_block_size;
> struct completion comp;
>
> unsigned long *frontswap_map;
> atomic_t frontswap_pages;
>
> spinlock_t lock;
># 286 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
> spinlock_t cont_lock;
>
>
>
> struct work_struct discard_work;
> struct swap_cluster_list discard_clusters;
> struct plist_node avail_lists[];
># 302 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>};
># 312 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>struct vma_swap_readahead {
> unsigned short win;
> unsigned short offset;
> unsigned short nr_pte;
>
> pte_t *ptes;
>
>
>
>};
>
>
>void workingset_age_nonresident(struct lruvec *lruvec, unsigned long nr_pages);
>void *workingset_eviction(struct page *page, struct mem_cgroup *target_memcg);
>void workingset_refault(struct page *page, void *shadow);
>void workingset_activation(struct page *page);
>
>
>void workingset_update_node(struct xa_node *node);
>
>
>
>
>
>
>extern unsigned long totalreserve_pages;
>extern unsigned long nr_free_buffer_pages(void);
>
>
>
>
>
>
>extern void lru_note_cost(struct lruvec *lruvec, bool file,
>     unsigned int nr_pages);
>extern void lru_note_cost_page(struct page *);
>extern void lru_cache_add(struct page *);
>extern void mark_page_accessed(struct page *);
>
>extern atomic_t lru_disable_count;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool lru_cache_disabled(void)
>{
> return atomic_read(&lru_disable_count);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lru_cache_enable(void)
>{
> atomic_dec(&lru_disable_count);
>}
>
>extern void lru_cache_disable(void);
>extern void lru_add_drain(void);
>extern void lru_add_drain_cpu(int cpu);
>extern void lru_add_drain_cpu_zone(struct zone *zone);
>extern void lru_add_drain_all(void);
>extern void rotate_reclaimable_page(struct page *page);
>extern void deactivate_file_page(struct page *page);
>extern void deactivate_page(struct page *page);
>extern void mark_page_lazyfree(struct page *page);
>extern void swap_setup(void);
>
>extern void lru_cache_add_inactive_or_unevictable(struct page *page,
>      struct vm_area_struct *vma);
>
>
>extern unsigned long zone_reclaimable_pages(struct zone *zone);
>extern unsigned long try_to_free_pages(struct zonelist *zonelist, int order,
>     gfp_t gfp_mask, nodemask_t *mask);
>extern bool __isolate_lru_page_prepare(struct page *page, isolate_mode_t mode);
>extern unsigned long try_to_free_mem_cgroup_pages(struct mem_cgroup *memcg,
>        unsigned long nr_pages,
>        gfp_t gfp_mask,
>        bool may_swap);
>extern unsigned long mem_cgroup_shrink_node(struct mem_cgroup *mem,
>      gfp_t gfp_mask, bool noswap,
>      pg_data_t *pgdat,
>      unsigned long *nr_scanned);
>extern unsigned long shrink_all_memory(unsigned long nr_pages);
>extern int vm_swappiness;
>extern int remove_mapping(struct address_space *mapping, struct page *page);
>
>extern unsigned long reclaim_pages(struct list_head *page_list);
>
>extern int node_reclaim_mode;
>extern int sysctl_min_unmapped_ratio;
>extern int sysctl_min_slab_ratio;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool node_reclaim_enabled(void)
>{
>
> return node_reclaim_mode & ((1<<0)|(1<<1)|(1<<2));
>}
>
>extern void check_move_unevictable_pages(struct pagevec *pvec);
>
>extern int kswapd_run(int nid);
>extern void kswapd_stop(int nid);
>
>
>
>
>
>
>extern int swap_readpage(struct page *page, bool do_poll);
>extern int swap_writepage(struct page *page, struct writeback_control *wbc);
>extern void end_swap_bio_write(struct bio *bio);
>extern int __swap_writepage(struct page *page, struct writeback_control *wbc,
> bio_end_io_t end_write_func);
>extern int swap_set_page_dirty(struct page *page);
>
>int add_swap_extent(struct swap_info_struct *sis, unsigned long start_page,
>  unsigned long nr_pages, sector_t start_block);
>int generic_swapfile_activate(struct swap_info_struct *, struct file *,
>  sector_t *);
>
>
>
>
>
>extern struct address_space *swapper_spaces[];
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long total_swapcache_pages(void)
>{
> return global_node_page_state(NR_SWAPCACHE);
>}
>
>extern void show_swap_cache_info(void);
>extern int add_to_swap(struct page *page);
>extern void *get_shadow_from_swap_cache(swp_entry_t entry);
>extern int add_to_swap_cache(struct page *page, swp_entry_t entry,
>   gfp_t gfp, void **shadowp);
>extern void __delete_from_swap_cache(struct page *page,
>   swp_entry_t entry, void *shadow);
>extern void delete_from_swap_cache(struct page *);
>extern void clear_shadow_from_swap_cache(int type, unsigned long begin,
>    unsigned long end);
>extern void free_swap_cache(struct page *);
>extern void free_page_and_swap_cache(struct page *);
>extern void free_pages_and_swap_cache(struct page **, int);
>extern struct page *lookup_swap_cache(swp_entry_t entry,
>          struct vm_area_struct *vma,
>          unsigned long addr);
>struct page *find_get_incore_page(struct address_space *mapping, unsigned long index);
>extern struct page *read_swap_cache_async(swp_entry_t, gfp_t,
>   struct vm_area_struct *vma, unsigned long addr,
>   bool do_poll);
>extern struct page *__read_swap_cache_async(swp_entry_t, gfp_t,
>   struct vm_area_struct *vma, unsigned long addr,
>   bool *new_page_allocated);
>extern struct page *swap_cluster_readahead(swp_entry_t entry, gfp_t flag,
>    struct vm_fault *vmf);
>extern struct page *swapin_readahead(swp_entry_t entry, gfp_t flag,
>    struct vm_fault *vmf);
>
>
>extern atomic_long_t nr_swap_pages;
>extern long total_swap_pages;
>extern atomic_t nr_rotate_swap;
>extern bool has_usable_swap(void);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool vm_swap_full(void)
>{
> return atomic_long_read(&nr_swap_pages) * 2 < total_swap_pages;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long get_nr_swap_pages(void)
>{
> return atomic_long_read(&nr_swap_pages);
>}
>
>extern void si_swapinfo(struct sysinfo *);
>extern swp_entry_t get_swap_page(struct page *page);
>extern void put_swap_page(struct page *page, swp_entry_t entry);
>extern swp_entry_t get_swap_page_of_type(int);
>extern int get_swap_pages(int n, swp_entry_t swp_entries[], int entry_size);
>extern int add_swap_count_continuation(swp_entry_t, gfp_t);
>extern void swap_shmem_alloc(swp_entry_t);
>extern int swap_duplicate(swp_entry_t);
>extern int swapcache_prepare(swp_entry_t);
>extern void swap_free(swp_entry_t);
>extern void swapcache_free_entries(swp_entry_t *entries, int n);
>extern int free_swap_and_cache(swp_entry_t);
>int swap_type_of(dev_t device, sector_t offset);
>int find_first_swap(dev_t *device);
>extern unsigned int count_swap_pages(int, int);
>extern sector_t swapdev_block(int, unsigned long);
>extern int page_swapcount(struct page *);
>extern int __swap_count(swp_entry_t entry);
>extern int __swp_swapcount(swp_entry_t entry);
>extern int swp_swapcount(swp_entry_t entry);
>extern struct swap_info_struct *page_swap_info(struct page *);
>extern struct swap_info_struct *swp_swap_info(swp_entry_t entry);
>extern bool reuse_swap_page(struct page *, int *);
>extern int try_to_free_swap(struct page *);
>struct backing_dev_info;
>extern int init_swap_address_space(unsigned int type, unsigned long nr_pages);
>extern void exit_swap_address_space(unsigned int type);
>extern struct swap_info_struct *get_swap_device(swp_entry_t entry);
>sector_t swap_page_sector(struct page *page);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void put_swap_device(struct swap_info_struct *si)
>{
> percpu_ref_put(&si->users);
>}
># 695 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>extern int split_swap_cluster(swp_entry_t entry);
># 704 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mem_cgroup_swappiness(struct mem_cgroup *memcg)
>{
>
> if (({ bool branch; if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_on_dfl_key), struct static_key_true)) branch = !arch_static_branch(&(&memory_cgrp_subsys_on_dfl_key)->key, true); else if (__builtin_types_compatible_p(typeof(*&memory_cgrp_subsys_on_dfl_key), struct static_key_false)) branch = !arch_static_branch_jump(&(&memory_cgrp_subsys_on_dfl_key)->key, true); else branch = ____wrong_branch_error(); __builtin_expect(!!(branch), 1); }))
>  return vm_swappiness;
>
>
> if (mem_cgroup_disabled() || mem_cgroup_is_root(memcg))
>  return vm_swappiness;
>
> return memcg->swappiness;
>}
># 724 "/usr/src/linux-5.14.21-150500.53/include/linux/swap.h"
>extern void __cgroup_throttle_swaprate(struct page *page, gfp_t gfp_mask);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void cgroup_throttle_swaprate(struct page *page, gfp_t gfp_mask)
>{
> if (mem_cgroup_disabled())
>  return;
> __cgroup_throttle_swaprate(page, gfp_mask);
>}
>
>
>
>
>
>
>
>extern void mem_cgroup_swapout(struct page *page, swp_entry_t entry);
>extern int __mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int mem_cgroup_try_charge_swap(struct page *page, swp_entry_t entry)
>{
> if (mem_cgroup_disabled())
>  return 0;
> return __mem_cgroup_try_charge_swap(page, entry);
>}
>
>extern void __mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages);
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void mem_cgroup_uncharge_swap(swp_entry_t entry, unsigned int nr_pages)
>{
> if (mem_cgroup_disabled())
>  return;
> __mem_cgroup_uncharge_swap(entry, nr_pages);
>}
>
>extern long mem_cgroup_get_nr_swap_pages(struct mem_cgroup *memcg);
>extern bool mem_cgroup_swap_full(struct page *page);
># 6 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/freezer.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/freezer.h"
>extern atomic_t system_freezing_cnt;
>extern bool pm_freezing;
>extern bool pm_nosig_freezing;
>
>
>
>
>extern unsigned int freeze_timeout_msecs;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool frozen(struct task_struct *p)
>{
> return p->flags & 0x00010000;
>}
>
>extern bool freezing_slow_path(struct task_struct *p);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool freezing(struct task_struct *p)
>{
> if (__builtin_expect(!!(!atomic_read(&system_freezing_cnt)), 1))
>  return false;
> return freezing_slow_path(p);
>}
>
>
>extern void __thaw_task(struct task_struct *t);
>
>extern bool __refrigerator(bool check_kthr_stop);
>extern int freeze_processes(void);
>extern int freeze_kernel_threads(void);
>extern void thaw_processes(void);
>extern void thaw_kernel_threads(void);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool try_to_freeze_unsafe(void)
>{
> do { might_resched(); } while (0);
> if (__builtin_expect(!!(!freezing(get_current())), 1))
>  return false;
> return __refrigerator(false);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool try_to_freeze(void)
>{
> if (!(get_current()->flags & 0x00008000))
>  debug_check_no_locks_held();
> return try_to_freeze_unsafe();
>}
>
>extern bool freeze_task(struct task_struct *p);
>extern bool set_freezable(void);
>
>
>extern bool cgroup_freezing(struct task_struct *task);
># 107 "/usr/src/linux-5.14.21-150500.53/include/linux/freezer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void freezer_do_not_count(void)
>{
> get_current()->flags |= 0x40000000;
>}
># 119 "/usr/src/linux-5.14.21-150500.53/include/linux/freezer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void freezer_count(void)
>{
> get_current()->flags &= ~0x40000000;
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> try_to_freeze();
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void freezer_count_unsafe(void)
>{
> get_current()->flags &= ~0x40000000;
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> try_to_freeze_unsafe();
>}
># 149 "/usr/src/linux-5.14.21-150500.53/include/linux/freezer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool freezer_should_skip(struct task_struct *p)
>{
>
>
>
>
>
>
>
> asm volatile("lock; addl $0,-4(%%" "rsp" ")" ::: "memory", "cc");
> return p->flags & 0x40000000;
>}
># 169 "/usr/src/linux-5.14.21-150500.53/include/linux/freezer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void freezable_schedule(void)
>{
> freezer_do_not_count();
> schedule();
> freezer_count();
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void freezable_schedule_unsafe(void)
>{
> freezer_do_not_count();
> schedule();
> freezer_count_unsafe();
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long freezable_schedule_timeout(long timeout)
>{
> long __retval;
> freezer_do_not_count();
> __retval = schedule_timeout(timeout);
> freezer_count();
> return __retval;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long freezable_schedule_timeout_interruptible(long timeout)
>{
> long __retval;
> freezer_do_not_count();
> __retval = schedule_timeout_interruptible(timeout);
> freezer_count();
> return __retval;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long freezable_schedule_timeout_interruptible_unsafe(long timeout)
>{
> long __retval;
>
> freezer_do_not_count();
> __retval = schedule_timeout_interruptible(timeout);
> freezer_count_unsafe();
> return __retval;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long freezable_schedule_timeout_killable(long timeout)
>{
> long __retval;
> freezer_do_not_count();
> __retval = schedule_timeout_killable(timeout);
> freezer_count();
> return __retval;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) long freezable_schedule_timeout_killable_unsafe(long timeout)
>{
> long __retval;
> freezer_do_not_count();
> __retval = schedule_timeout_killable(timeout);
> freezer_count_unsafe();
> return __retval;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int freezable_schedule_hrtimeout_range(ktime_t *expires,
>  u64 delta, const enum hrtimer_mode mode)
>{
> int __retval;
> freezer_do_not_count();
> __retval = schedule_hrtimeout_range(expires, delta, mode);
> freezer_count();
> return __retval;
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/errno.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h" 2
>
>
>extern void pm_set_vt_switch(int);
>
>
>
>
>
>
>
>extern void pm_prepare_console(void);
>extern void pm_restore_console(void);
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>typedef int suspend_state_t;
># 43 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>enum suspend_stat_step {
> SUSPEND_FREEZE = 1,
> SUSPEND_PREPARE,
> SUSPEND_SUSPEND,
> SUSPEND_SUSPEND_LATE,
> SUSPEND_SUSPEND_NOIRQ,
> SUSPEND_RESUME_NOIRQ,
> SUSPEND_RESUME_EARLY,
> SUSPEND_RESUME
>};
>
>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[2][40];
> int last_failed_errno;
> int errno[2];
> int last_failed_step;
> enum suspend_stat_step failed_steps[2];
>};
>
>extern struct suspend_stats suspend_stats;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dpm_save_failed_dev(const char *name)
>{
> strlcpy(suspend_stats.failed_devs[suspend_stats.last_failed_dev],
>  name,
>  sizeof(suspend_stats.failed_devs[0]));
> suspend_stats.last_failed_dev++;
> suspend_stats.last_failed_dev %= 2;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dpm_save_failed_errno(int err)
>{
> suspend_stats.errno[suspend_stats.last_failed_errno] = err;
> suspend_stats.last_failed_errno++;
> suspend_stats.last_failed_errno %= 2;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void dpm_save_failed_step(enum suspend_stat_step step)
>{
> suspend_stats.failed_steps[suspend_stats.last_failed_step] = step;
> suspend_stats.last_failed_step++;
> suspend_stats.last_failed_step %= 2;
>}
># 177 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>struct platform_suspend_ops {
> int (*valid)(suspend_state_t state);
> int (*begin)(suspend_state_t state);
> int (*prepare)(void);
> int (*prepare_late)(void);
> int (*enter)(suspend_state_t state);
> void (*wake)(void);
> void (*finish)(void);
> bool (*suspend_again)(void);
> void (*end)(void);
> void (*recover)(void);
>};
>
>struct platform_s2idle_ops {
> int (*begin)(void);
> int (*prepare)(void);
> int (*prepare_late)(void);
> bool (*wake)(void);
> void (*restore_early)(void);
> void (*restore)(void);
> void (*end)(void);
>};
>
>
>extern suspend_state_t mem_sleep_current;
>extern suspend_state_t mem_sleep_default;
>
>
>
>
>
>extern void suspend_set_ops(const struct platform_suspend_ops *ops);
>extern int suspend_valid_only_mem(suspend_state_t state);
>
>extern unsigned int pm_suspend_global_flags;
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pm_suspend_clear_flags(void)
>{
> pm_suspend_global_flags = 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pm_set_suspend_via_firmware(void)
>{
> pm_suspend_global_flags |= ((((1UL))) << (0));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pm_set_resume_via_firmware(void)
>{
> pm_suspend_global_flags |= ((((1UL))) << (1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pm_set_suspend_no_platform(void)
>{
> pm_suspend_global_flags |= ((((1UL))) << (2));
>}
># 257 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pm_suspend_via_firmware(void)
>{
> return !!(pm_suspend_global_flags & ((((1UL))) << (0)));
>}
># 273 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pm_resume_via_firmware(void)
>{
> return !!(pm_suspend_global_flags & ((((1UL))) << (1)));
>}
># 289 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool pm_suspend_no_platform(void)
>{
> return !!(pm_suspend_global_flags & ((((1UL))) << (2)));
>}
>
>
>enum s2idle_states {
> S2IDLE_STATE_NONE,
> S2IDLE_STATE_ENTER,
> S2IDLE_STATE_WAKE,
>};
>
>extern enum s2idle_states __attribute__((__section__(".data..read_mostly"))) s2idle_state;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool idle_should_enter_s2idle(void)
>{
> return __builtin_expect(!!(s2idle_state == S2IDLE_STATE_ENTER), 0);
>}
>
>extern bool pm_suspend_default_s2idle(void);
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) pm_states_init(void);
>extern void s2idle_set_ops(const struct platform_s2idle_ops *ops);
>extern void s2idle_wake(void);
># 320 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>extern void arch_suspend_disable_irqs(void);
># 329 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>extern void arch_suspend_enable_irqs(void);
>
>extern int pm_suspend(suspend_state_t state);
>extern bool sync_on_suspend_enabled;
># 357 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>struct pbe {
> void *address;
> void *orig_address;
> struct pbe *next;
>};
>
>
>extern void mark_free_pages(struct zone *zone);
># 418 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>struct platform_hibernation_ops {
> int (*begin)(pm_message_t stage);
> 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);
>};
>
>
>
>extern void register_nosave_region(unsigned long b, unsigned long e);
>extern int swsusp_page_is_forbidden(struct page *);
>extern void swsusp_set_page_free(struct page *);
>extern void swsusp_unset_page_free(struct page *);
>extern unsigned long get_safe_page(gfp_t gfp_mask);
>extern int swsusp_arch_suspend(void);
>extern int swsusp_arch_resume(void);
>
>extern u32 swsusp_hardware_signature;
>extern void hibernation_set_ops(const struct platform_hibernation_ops *ops);
>extern int hibernate(void);
>extern bool system_entering_hibernation(void);
>extern bool hibernation_available(void);
> int swsusp_save(void);
>extern struct pbe *restore_pblist;
>int pfn_is_nosave(unsigned long pfn);
>
>int hibernate_quiet_exec(int (*func)(void *data), void *data);
># 468 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>int is_hibernate_resume_dev(dev_t dev);
># 481 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>extern struct mutex system_transition_mutex;
>
>
>void save_processor_state(void);
>void restore_processor_state(void);
>
>
>extern int register_pm_notifier(struct notifier_block *nb);
>extern int unregister_pm_notifier(struct notifier_block *nb);
>extern void ksys_sync_helper(void);
># 499 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>extern bool events_check_enabled;
>extern suspend_state_t pm_suspend_target_state;
>
>extern bool pm_wakeup_pending(void);
>extern void pm_system_wakeup(void);
>extern void pm_system_cancel_wakeup(void);
>extern void pm_wakeup_clear(unsigned int irq_number);
>extern void pm_system_irq_wakeup(unsigned int irq_number);
>extern unsigned int pm_wakeup_irq(void);
>extern bool pm_get_wakeup_count(unsigned int *count, bool block);
>extern bool pm_save_wakeup_count(unsigned int count);
>extern void pm_wakep_autosleep_enabled(bool set);
>extern void pm_print_active_wakeup_sources(void);
>
>extern void lock_system_sleep(void);
>extern void unlock_system_sleep(void);
># 543 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>extern bool pm_print_times_enabled;
>extern bool pm_debug_messages_on;
>extern __attribute__((__format__(printf, 2, 3))) void __pm_pr_dbg(bool defer, const char *fmt, ...);
># 569 "/usr/src/linux-5.14.21-150500.53/include/linux/suspend.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void queue_up_suspend_work(void) {}
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/regulator/consumer.h" 2
>
>struct device;
>struct notifier_block;
>struct regmap;
>struct regulator_dev;
># 163 "/usr/src/linux-5.14.21-150500.53/include/linux/regulator/consumer.h"
>struct pre_voltage_change_data {
> unsigned long old_uV;
> unsigned long min_uV;
> unsigned long max_uV;
>};
>
>struct regulator;
># 183 "/usr/src/linux-5.14.21-150500.53/include/linux/regulator/consumer.h"
>struct regulator_bulk_data {
> const char *supply;
> struct regulator *consumer;
>
>
> int ret;
>};
>
>
>
>
>struct regulator *__attribute__((__warn_unused_result__)) regulator_get(struct device *dev,
>          const char *id);
>struct regulator *__attribute__((__warn_unused_result__)) devm_regulator_get(struct device *dev,
>          const char *id);
>struct regulator *__attribute__((__warn_unused_result__)) regulator_get_exclusive(struct device *dev,
>             const char *id);
>struct regulator *__attribute__((__warn_unused_result__)) devm_regulator_get_exclusive(struct device *dev,
>       const char *id);
>struct regulator *__attribute__((__warn_unused_result__)) regulator_get_optional(struct device *dev,
>            const char *id);
>struct regulator *__attribute__((__warn_unused_result__)) devm_regulator_get_optional(struct device *dev,
>          const char *id);
>void regulator_put(struct regulator *regulator);
>void devm_regulator_put(struct regulator *regulator);
>
>int regulator_register_supply_alias(struct device *dev, const char *id,
>        struct device *alias_dev,
>        const char *alias_id);
>void regulator_unregister_supply_alias(struct device *dev, const char *id);
>
>int regulator_bulk_register_supply_alias(struct device *dev,
>      const char *const *id,
>      struct device *alias_dev,
>      const char *const *alias_id,
>      int num_id);
>void regulator_bulk_unregister_supply_alias(struct device *dev,
>         const char * const *id, int num_id);
>
>int devm_regulator_register_supply_alias(struct device *dev, const char *id,
>      struct device *alias_dev,
>      const char *alias_id);
>void devm_regulator_unregister_supply_alias(struct device *dev,
>         const char *id);
>
>int devm_regulator_bulk_register_supply_alias(struct device *dev,
>           const char *const *id,
>           struct device *alias_dev,
>           const char *const *alias_id,
>           int num_id);
>void devm_regulator_bulk_unregister_supply_alias(struct device *dev,
>       const char *const *id,
>       int num_id);
>
>
>int __attribute__((__warn_unused_result__)) regulator_enable(struct regulator *regulator);
>int regulator_disable(struct regulator *regulator);
>int regulator_force_disable(struct regulator *regulator);
>int regulator_is_enabled(struct regulator *regulator);
>int regulator_disable_deferred(struct regulator *regulator, int ms);
>
>int __attribute__((__warn_unused_result__)) regulator_bulk_get(struct device *dev, int num_consumers,
>        struct regulator_bulk_data *consumers);
>int __attribute__((__warn_unused_result__)) devm_regulator_bulk_get(struct device *dev, int num_consumers,
>      struct regulator_bulk_data *consumers);
>int __attribute__((__warn_unused_result__)) regulator_bulk_enable(int num_consumers,
>           struct regulator_bulk_data *consumers);
>int regulator_bulk_disable(int num_consumers,
>      struct regulator_bulk_data *consumers);
>int regulator_bulk_force_disable(int num_consumers,
>      struct regulator_bulk_data *consumers);
>void regulator_bulk_free(int num_consumers,
>    struct regulator_bulk_data *consumers);
>
>int regulator_count_voltages(struct regulator *regulator);
>int regulator_list_voltage(struct regulator *regulator, unsigned selector);
>int regulator_is_supported_voltage(struct regulator *regulator,
>       int min_uV, int max_uV);
>unsigned int regulator_get_linear_step(struct regulator *regulator);
>int regulator_set_voltage(struct regulator *regulator, int min_uV, int max_uV);
>int regulator_set_voltage_time(struct regulator *regulator,
>          int old_uV, int new_uV);
>int regulator_get_voltage(struct regulator *regulator);
>int regulator_sync_voltage(struct regulator *regulator);
>int regulator_set_current_limit(struct regulator *regulator,
>          int min_uA, int max_uA);
>int regulator_get_current_limit(struct regulator *regulator);
>
>int regulator_set_mode(struct regulator *regulator, unsigned int mode);
>unsigned int regulator_get_mode(struct regulator *regulator);
>int regulator_get_error_flags(struct regulator *regulator,
>    unsigned int *flags);
>int regulator_set_load(struct regulator *regulator, int load_uA);
>
>int regulator_allow_bypass(struct regulator *regulator, bool allow);
>
>struct regmap *regulator_get_regmap(struct regulator *regulator);
>int regulator_get_hardware_vsel_register(struct regulator *regulator,
>      unsigned *vsel_reg,
>      unsigned *vsel_mask);
>int regulator_list_hardware_vsel(struct regulator *regulator,
>     unsigned selector);
>
>
>int regulator_register_notifier(struct regulator *regulator,
>         struct notifier_block *nb);
>int devm_regulator_register_notifier(struct regulator *regulator,
>         struct notifier_block *nb);
>int regulator_unregister_notifier(struct regulator *regulator,
>    struct notifier_block *nb);
>void devm_regulator_unregister_notifier(struct regulator *regulator,
>     struct notifier_block *nb);
>
>
>int regulator_suspend_enable(struct regulator_dev *rdev,
>        suspend_state_t state);
>int regulator_suspend_disable(struct regulator_dev *rdev,
>         suspend_state_t state);
>int regulator_set_suspend_voltage(struct regulator *regulator, int min_uV,
>      int max_uV, suspend_state_t state);
>
>
>void *regulator_get_drvdata(struct regulator *regulator);
>void regulator_set_drvdata(struct regulator *regulator, void *data);
>
>
>
>void regulator_bulk_set_supply_names(struct regulator_bulk_data *consumers,
>         const char *const *supply_names,
>         unsigned int num_supplies);
>
>bool regulator_is_equal(struct regulator *reg1, struct regulator *reg2);
># 659 "/usr/src/linux-5.14.21-150500.53/include/linux/regulator/consumer.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int regulator_set_voltage_triplet(struct regulator *regulator,
>      int min_uV, int target_uV,
>      int max_uV)
>{
> if (regulator_set_voltage(regulator, target_uV, max_uV) == 0)
>  return 0;
>
> return regulator_set_voltage(regulator, min_uV, max_uV);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int regulator_set_voltage_tol(struct regulator *regulator,
>         int new_uV, int tol_uV)
>{
> if (regulator_set_voltage(regulator, new_uV, new_uV + tol_uV) == 0)
>  return 0;
> else
>  return regulator_set_voltage(regulator,
>          new_uV - tol_uV, new_uV + tol_uV);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int regulator_is_supported_voltage_tol(struct regulator *regulator,
>           int target_uV, int tol_uV)
>{
> return regulator_is_supported_voltage(regulator,
>           target_uV - tol_uV,
>           target_uV + tol_uV);
>}
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h" 2
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/i2c.h" 1
># 73 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/i2c.h"
>struct i2c_msg {
> __u16 addr;
> __u16 flags;
># 85 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/i2c.h"
> __u16 len;
> __u8 *buf;
>};
># 141 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/i2c.h"
>union i2c_smbus_data {
> __u8 byte;
> __u16 word;
> __u8 block[32 + 2];
>
>};
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h" 2
>
>extern struct bus_type i2c_bus_type;
>extern struct device_type i2c_adapter_type;
>extern struct device_type i2c_client_type;
>
>
>
>struct i2c_msg;
>struct i2c_algorithm;
>struct i2c_adapter;
>struct i2c_client;
>struct i2c_driver;
>struct i2c_device_identity;
>union i2c_smbus_data;
>struct i2c_board_info;
>enum i2c_slave_event;
>typedef int (*i2c_slave_cb_t)(struct i2c_client *client,
>         enum i2c_slave_event event, u8 *val);
># 51 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct module;
>struct property_entry;
>
>
>
>const char *i2c_freq_mode_string(u32 bus_freq_hz);
># 65 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>int i2c_transfer_buffer_flags(const struct i2c_client *client,
>         char *buf, int count, u16 flags);
># 76 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i2c_master_recv(const struct i2c_client *client,
>      char *buf, int count)
>{
> return i2c_transfer_buffer_flags(client, buf, count, 0x0001);
>};
># 91 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i2c_master_recv_dmasafe(const struct i2c_client *client,
>       char *buf, int count)
>{
> return i2c_transfer_buffer_flags(client, buf, count,
>      0x0001 | 0x0200);
>};
># 106 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i2c_master_send(const struct i2c_client *client,
>      const char *buf, int count)
>{
> return i2c_transfer_buffer_flags(client, (char *)buf, count, 0);
>};
># 121 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i2c_master_send_dmasafe(const struct i2c_client *client,
>       const char *buf, int count)
>{
> return i2c_transfer_buffer_flags(client, (char *)buf, count,
>      0x0200);
>};
>
>
>
>int i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
>
>int __i2c_transfer(struct i2c_adapter *adap, struct i2c_msg *msgs, int num);
>
>
>
>
>
>
>s32 i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
>     unsigned short flags, char read_write, u8 command,
>     int protocol, union i2c_smbus_data *data);
>
>
>s32 __i2c_smbus_xfer(struct i2c_adapter *adapter, u16 addr,
>       unsigned short flags, char read_write, u8 command,
>       int protocol, union i2c_smbus_data *data);
>
>
>
>
>u8 i2c_smbus_pec(u8 crc, u8 *p, size_t count);
>s32 i2c_smbus_read_byte(const struct i2c_client *client);
>s32 i2c_smbus_write_byte(const struct i2c_client *client, u8 value);
>s32 i2c_smbus_read_byte_data(const struct i2c_client *client, u8 command);
>s32 i2c_smbus_write_byte_data(const struct i2c_client *client,
>         u8 command, u8 value);
>s32 i2c_smbus_read_word_data(const struct i2c_client *client, u8 command);
>s32 i2c_smbus_write_word_data(const struct i2c_client *client,
>         u8 command, u16 value);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s32
>i2c_smbus_read_word_swapped(const struct i2c_client *client, u8 command)
>{
> s32 value = i2c_smbus_read_word_data(client, command);
>
> return (value < 0) ? value : (__u16)__builtin_bswap16((__u16)(value));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) s32
>i2c_smbus_write_word_swapped(const struct i2c_client *client,
>        u8 command, u16 value)
>{
> return i2c_smbus_write_word_data(client, command, (__u16)__builtin_bswap16((__u16)(value)));
>}
>
>
>s32 i2c_smbus_read_block_data(const struct i2c_client *client,
>         u8 command, u8 *values);
>s32 i2c_smbus_write_block_data(const struct i2c_client *client,
>          u8 command, u8 length, const u8 *values);
>
>s32 i2c_smbus_read_i2c_block_data(const struct i2c_client *client,
>      u8 command, u8 length, u8 *values);
>s32 i2c_smbus_write_i2c_block_data(const struct i2c_client *client,
>       u8 command, u8 length, const u8 *values);
>s32 i2c_smbus_read_i2c_block_data_or_emulated(const struct i2c_client *client,
>           u8 command, u8 length,
>           u8 *values);
>int i2c_get_device_id(const struct i2c_client *client,
>        struct i2c_device_identity *id);
># 199 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_device_identity {
> u16 manufacturer_id;
># 216 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
> u16 part_id;
> u8 die_revision;
>};
>
>enum i2c_alert_protocol {
> I2C_PROTOCOL_SMBUS_ALERT,
> I2C_PROTOCOL_SMBUS_HOST_NOTIFY,
>};
># 260 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_driver {
> unsigned int class;
>
>
> int (*probe)(struct i2c_client *client, const struct i2c_device_id *id);
> int (*remove)(struct i2c_client *client);
>
>
>
>
> int (*probe_new)(struct i2c_client *client);
>
>
> void (*shutdown)(struct i2c_client *client);
># 282 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
> void (*alert)(struct i2c_client *client, enum i2c_alert_protocol protocol,
>        unsigned int data);
>
>
>
>
> int (*command)(struct i2c_client *client, unsigned int cmd, void *arg);
>
> struct device_driver driver;
> const struct i2c_device_id *id_table;
>
>
> int (*detect)(struct i2c_client *client, struct i2c_board_info *info);
> const unsigned short *address_list;
> struct list_head clients;
>};
># 321 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_client {
> unsigned short flags;
># 332 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
> unsigned short addr;
>
>
> char name[20];
> struct i2c_adapter *adapter;
> struct device dev;
> int init_irq;
> int irq;
> struct list_head detected;
>
>
>
> void *devres_group_id;
>};
>
>
>struct i2c_adapter *i2c_verify_adapter(struct device *dev);
>const struct i2c_device_id *i2c_match_id(const struct i2c_device_id *id,
>      const struct i2c_client *client);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct i2c_client *kobj_to_i2c_client(struct kobject *kobj)
>{
> struct device * const dev = kobj_to_dev(kobj);
> return ({ void *__mptr = (void *)(dev); do { extern void __compiletime_assert_362(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(dev)), typeof(((struct i2c_client *)0)->dev)) && !__builtin_types_compatible_p(typeof(*(dev)), typeof(void))))) __compiletime_assert_362(); } while (0); ((struct i2c_client *)(__mptr - __builtin_offsetof(struct i2c_client, dev))); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *i2c_get_clientdata(const struct i2c_client *client)
>{
> return dev_get_drvdata(&client->dev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i2c_set_clientdata(struct i2c_client *client, void *data)
>{
> dev_set_drvdata(&client->dev, data);
>}
># 389 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool i2c_detect_slave_mode(struct device *dev) { return false; }
># 417 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_board_info {
> char type[20];
> unsigned short flags;
> unsigned short addr;
> const char *dev_name;
> void *platform_data;
> struct device_node *of_node;
> struct fwnode_handle *fwnode;
> const struct software_node *swnode;
> const struct resource *resources;
> unsigned int num_resources;
> int irq;
>};
># 451 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_client *
>i2c_new_client_device(struct i2c_adapter *adap, struct i2c_board_info const *info);
>
>
>
>
>
>
>
>struct i2c_client *
>i2c_new_scanned_device(struct i2c_adapter *adap,
>         struct i2c_board_info *info,
>         unsigned short const *addr_list,
>         int (*probe)(struct i2c_adapter *adap, unsigned short addr));
>
>
>int i2c_probe_func_quick_read(struct i2c_adapter *adap, unsigned short addr);
>
>struct i2c_client *
>i2c_new_dummy_device(struct i2c_adapter *adapter, u16 address);
>
>struct i2c_client *
>devm_i2c_new_dummy_device(struct device *dev, struct i2c_adapter *adap, u16 address);
>
>struct i2c_client *
>i2c_new_ancillary_device(struct i2c_client *client,
>    const char *name,
>    u16 default_addr);
>
>void i2c_unregister_device(struct i2c_client *client);
>
>struct i2c_client *i2c_verify_client(struct device *dev);
># 495 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>int
>i2c_register_board_info(int busnum, struct i2c_board_info const *info,
>   unsigned n);
># 533 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_algorithm {
># 543 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
> int (*master_xfer)(struct i2c_adapter *adap, struct i2c_msg *msgs,
>      int num);
> int (*master_xfer_atomic)(struct i2c_adapter *adap,
>       struct i2c_msg *msgs, int num);
> int (*smbus_xfer)(struct i2c_adapter *adap, u16 addr,
>     unsigned short flags, char read_write,
>     u8 command, int size, union i2c_smbus_data *data);
> int (*smbus_xfer_atomic)(struct i2c_adapter *adap, u16 addr,
>     unsigned short flags, char read_write,
>     u8 command, int size, union i2c_smbus_data *data);
>
>
> u32 (*functionality)(struct i2c_adapter *adap);
>
>
>
>
>
>};
># 571 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_lock_operations {
> void (*lock_bus)(struct i2c_adapter *adapter, unsigned int flags);
> int (*trylock_bus)(struct i2c_adapter *adapter, unsigned int flags);
> void (*unlock_bus)(struct i2c_adapter *adapter, unsigned int flags);
>};
># 590 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_timings {
> u32 bus_freq_hz;
> u32 scl_rise_ns;
> u32 scl_fall_ns;
> u32 scl_int_delay_ns;
> u32 sda_fall_ns;
> u32 sda_hold_ns;
> u32 digital_filter_width_ns;
> u32 analog_filter_cutoff_freq_hz;
>};
># 632 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_bus_recovery_info {
> int (*recover_bus)(struct i2c_adapter *adap);
>
> int (*get_scl)(struct i2c_adapter *adap);
> void (*set_scl)(struct i2c_adapter *adap, int val);
> int (*get_sda)(struct i2c_adapter *adap);
> void (*set_sda)(struct i2c_adapter *adap, int val);
> int (*get_bus_free)(struct i2c_adapter *adap);
>
> void (*prepare_recovery)(struct i2c_adapter *adap);
> void (*unprepare_recovery)(struct i2c_adapter *adap);
>
>
> struct gpio_desc *scl_gpiod;
> struct gpio_desc *sda_gpiod;
> struct pinctrl *pinctrl;
> struct pinctrl_state *pins_default;
> struct pinctrl_state *pins_gpio;
>};
>
>int i2c_recover_bus(struct i2c_adapter *adap);
>
>
>int i2c_generic_scl_recovery(struct i2c_adapter *adap);
># 678 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>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;
>};
># 711 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>struct i2c_adapter {
> struct module *owner;
> unsigned int class;
> const struct i2c_algorithm *algo;
> void *algo_data;
>
>
> const struct i2c_lock_operations *lock_ops;
> struct rt_mutex bus_lock;
> struct rt_mutex mux_lock;
>
> int timeout;
> int retries;
> struct device dev;
> unsigned long locked_flags;
>
>
>
> int nr;
> char name[48];
> struct completion dev_released;
>
> struct mutex userspace_clients_lock;
> struct list_head userspace_clients;
>
> struct i2c_bus_recovery_info *bus_recovery_info;
> const struct i2c_adapter_quirks *quirks;
>
> struct irq_domain *host_notify_domain;
> struct regulator *bus_regulator;
>};
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *i2c_get_adapdata(const struct i2c_adapter *adap)
>{
> return dev_get_drvdata(&adap->dev);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i2c_set_adapdata(struct i2c_adapter *adap, void *data)
>{
> dev_set_drvdata(&adap->dev, data);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct i2c_adapter *
>i2c_parent_is_i2c_adapter(const struct i2c_adapter *adapter)
>{
>
> struct device *parent = adapter->dev.parent;
>
> if (parent != ((void *)0) && parent->type == &i2c_adapter_type)
>  return ({ void *__mptr = (void *)(parent); do { extern void __compiletime_assert_363(void) __attribute__((__error__("pointer type mismatch in container_of()"))); if (!(!(!__builtin_types_compatible_p(typeof(*(parent)), typeof(((struct i2c_adapter *)0)->dev)) && !__builtin_types_compatible_p(typeof(*(parent)), typeof(void))))) __compiletime_assert_363(); } while (0); ((struct i2c_adapter *)(__mptr - __builtin_offsetof(struct i2c_adapter, dev))); });
> else
>
>  return ((void *)0);
>}
>
>int i2c_for_each_dev(void *data, int (*fn)(struct device *dev, void *data));
># 779 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>i2c_lock_bus(struct i2c_adapter *adapter, unsigned int flags)
>{
> adapter->lock_ops->lock_bus(adapter, flags);
>}
># 793 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>i2c_trylock_bus(struct i2c_adapter *adapter, unsigned int flags)
>{
> return adapter->lock_ops->trylock_bus(adapter, flags);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void
>i2c_unlock_bus(struct i2c_adapter *adapter, unsigned int flags)
>{
> adapter->lock_ops->unlock_bus(adapter, flags);
>}
># 821 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i2c_mark_adapter_suspended(struct i2c_adapter *adap)
>{
> i2c_lock_bus(adap, ((((1UL))) << (0)));
> set_bit(0, &adap->locked_flags);
> i2c_unlock_bus(adap, ((((1UL))) << (0)));
>}
># 836 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void i2c_mark_adapter_resumed(struct i2c_adapter *adap)
>{
> i2c_lock_bus(adap, ((((1UL))) << (0)));
> clear_bit(0, &adap->locked_flags);
> i2c_unlock_bus(adap, ((((1UL))) << (0)));
>}
># 863 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>int i2c_add_adapter(struct i2c_adapter *adap);
>int devm_i2c_add_adapter(struct device *dev, struct i2c_adapter *adapter);
>void i2c_del_adapter(struct i2c_adapter *adap);
>int i2c_add_numbered_adapter(struct i2c_adapter *adap);
>
>int i2c_register_driver(struct module *owner, struct i2c_driver *driver);
>void i2c_del_driver(struct i2c_driver *driver);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool i2c_client_has_driver(struct i2c_client *client)
>{
> return !IS_ERR_OR_NULL(client) && client->dev.driver;
>}
>
>
>
>void i2c_clients_command(struct i2c_adapter *adap,
>    unsigned int cmd, void *arg);
>
>struct i2c_adapter *i2c_get_adapter(int nr);
>void i2c_put_adapter(struct i2c_adapter *adap);
>unsigned int i2c_adapter_depth(struct i2c_adapter *adapter);
>
>void i2c_parse_fw_timings(struct device *dev, struct i2c_timings *t, bool use_defaults);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u32 i2c_get_functionality(struct i2c_adapter *adap)
>{
> return adap->algo->functionality(adap);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i2c_check_functionality(struct i2c_adapter *adap, u32 func)
>{
> return (func & i2c_get_functionality(adap)) == func;
>}
># 910 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool i2c_check_quirks(struct i2c_adapter *adap, u64 quirks)
>{
> if (!adap->quirks)
>  return false;
> return (adap->quirks->flags & quirks) == quirks;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int i2c_adapter_id(struct i2c_adapter *adap)
>{
> return adap->nr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) u8 i2c_8bit_addr_from_msg(const struct i2c_msg *msg)
>{
> return (msg->addr << 1) | (msg->flags & 0x0001 ? 1 : 0);
>}
>
>u8 *i2c_get_dma_safe_msg_buf(struct i2c_msg *msg, unsigned int threshold);
>void i2c_put_dma_safe_msg_buf(u8 *buf, struct i2c_msg *msg, bool xferred);
>
>int i2c_handle_smbus_host_notify(struct i2c_adapter *adap, unsigned short addr);
># 976 "/usr/src/linux-5.14.21-150500.53/include/linux/i2c.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct i2c_client *of_find_i2c_device_by_node(struct device_node *node)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct i2c_adapter *of_find_i2c_adapter_by_node(struct device_node *node)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct i2c_adapter *of_get_i2c_adapter_by_node(struct device_node *node)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) const struct of_device_id
>*i2c_of_match_device(const struct of_device_id *matches,
>       struct i2c_client *client)
>{
> return ((void *)0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int of_i2c_get_board_info(struct device *dev,
>     struct device_node *node,
>     struct i2c_board_info *info)
>{
> return -524;
>}
>
>
>
>struct acpi_resource;
>struct acpi_resource_i2c_serialbus;
>
>
>bool i2c_acpi_get_i2c_resource(struct acpi_resource *ares,
>          struct acpi_resource_i2c_serialbus **i2c);
>int i2c_acpi_client_count(struct acpi_device *adev);
>u32 i2c_acpi_find_bus_speed(struct device *dev);
>struct i2c_client *i2c_acpi_new_device(struct device *dev, int index,
>           struct i2c_board_info *info);
>struct i2c_adapter *i2c_acpi_find_adapter_by_handle(acpi_handle handle);
># 327 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 337 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/acpi/video.h" 1
>
>
>
>
>
>
>
>struct acpi_video_brightness_flags {
> u8 _BCL_no_ac_battery_levels:1;
> u8 _BCL_reversed:1;
> u8 _BQC_use_index:1;
>};
>
>struct acpi_video_device_brightness {
> int curr;
> int count;
> int *levels;
> struct acpi_video_brightness_flags flags;
>};
>
>struct acpi_device;
># 45 "/usr/src/linux-5.14.21-150500.53/include/acpi/video.h"
>enum acpi_backlight_type {
> acpi_backlight_undef = -1,
> acpi_backlight_none = 0,
> acpi_backlight_video,
> acpi_backlight_vendor,
> acpi_backlight_native,
>};
>
>
>extern int acpi_video_register(void);
>extern void acpi_video_unregister(void);
>extern void acpi_video_register_backlight(void);
>extern int acpi_video_get_edid(struct acpi_device *device, int type,
>          int device_id, void **edid);
>extern enum acpi_backlight_type acpi_video_get_backlight_type(void);
>extern void acpi_video_set_dmi_backlight_type(enum acpi_backlight_type type);
>
>
>
>
>extern bool acpi_video_handles_brightness_key_presses(void);
>extern int acpi_video_get_levels(struct acpi_device *device,
>     struct acpi_video_device_brightness **dev_br,
>     int *pmax_level);
># 338 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi_msgdefs.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h" 2
># 51 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_addr {
>
>
> int addr_type;
> short channel;
> char data[32];
>};
>
>
>
>
>
>
>
>struct ipmi_system_interface_addr {
> int addr_type;
> short channel;
> unsigned char lun;
>};
>
>
>
>
>
>
>struct ipmi_ipmb_addr {
> int addr_type;
> short channel;
> unsigned char slave_addr;
> unsigned char lun;
>};
># 101 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_lan_addr {
> int addr_type;
> short channel;
> unsigned char privilege;
> unsigned char session_handle;
> unsigned char remote_SWID;
> unsigned char local_SWID;
> unsigned char lun;
>};
># 134 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_msg {
> unsigned char netfn;
> unsigned char cmd;
> unsigned short data_len;
> unsigned char *data;
>};
>
>struct kernel_ipmi_msg {
> unsigned char netfn;
> unsigned char cmd;
> unsigned short data_len;
> unsigned char *data;
>};
># 233 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_req {
> unsigned char *addr;
> unsigned int addr_len;
>
> long msgid;
>
>
>
>
>
> struct ipmi_msg msg;
>};
># 258 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_req_settime {
> struct ipmi_req req;
>
>
>
> int retries;
> unsigned int retry_time_ms;
>};
># 279 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_recv {
> int recv_type;
>
>
> unsigned char *addr;
>
>
> unsigned int addr_len;
>
>
>
>
>
> long msgid;
>
>
>
>
> struct ipmi_msg msg;
>
>
>
>
>
>
>};
># 325 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_cmdspec {
> unsigned char netfn;
> unsigned char cmd;
>};
># 353 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_cmdspec_chans {
> unsigned int netfn;
> unsigned int cmd;
> unsigned int chans;
>};
># 391 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_channel_lun_address_set {
> unsigned short channel;
> unsigned char value;
>};
># 413 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ipmi.h"
>struct ipmi_timing_parms {
> int retries;
> unsigned int retry_time_ms;
>};
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h" 2
>
>
>
>
>
>struct module;
>struct device;
>
>
>
>
>
>struct ipmi_user;
># 39 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>struct ipmi_recv_msg {
> struct list_head link;
>
>
>
>
>
> int recv_type;
>
> struct ipmi_user *user;
> struct ipmi_addr addr;
> long msgid;
> struct kernel_ipmi_msg msg;
># 60 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
> void *user_msg_data;
>
>
>
>
>
> void (*done)(struct ipmi_recv_msg *msg);
>
>
>
>
>
> unsigned char msg_data[272];
>};
>
>
>void ipmi_free_recv_msg(struct ipmi_recv_msg *msg);
>
>struct ipmi_user_hndl {
>
>
>
>
>
>
>
> void (*ipmi_recv_hndl)(struct ipmi_recv_msg *msg,
>          void *user_msg_data);
>
>
>
>
>
> void (*ipmi_watchdog_pretimeout)(void *handler_data);
>
>
>
>
>
> void (*ipmi_panic_handler)(void *handler_data);
>
>
>
>
>
>
>
> void (*shutdown)(void *handler_data);
>};
>
>
>int ipmi_create_user(unsigned int if_num,
>       const struct ipmi_user_hndl *handler,
>       void *handler_data,
>       struct ipmi_user **user);
># 124 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>int ipmi_destroy_user(struct ipmi_user *user);
>
>
>int ipmi_get_version(struct ipmi_user *user,
>       unsigned char *major,
>       unsigned char *minor);
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>int ipmi_set_my_address(struct ipmi_user *user,
>   unsigned int channel,
>   unsigned char address);
>int ipmi_get_my_address(struct ipmi_user *user,
>   unsigned int channel,
>   unsigned char *address);
>int ipmi_set_my_LUN(struct ipmi_user *user,
>      unsigned int channel,
>      unsigned char LUN);
>int ipmi_get_my_LUN(struct ipmi_user *user,
>      unsigned int channel,
>      unsigned char *LUN);
># 166 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>int ipmi_request_settime(struct ipmi_user *user,
>    struct ipmi_addr *addr,
>    long msgid,
>    struct kernel_ipmi_msg *msg,
>    void *user_msg_data,
>    int priority,
>    int max_retries,
>    unsigned int retry_time_ms);
># 184 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>int ipmi_request_supply_msgs(struct ipmi_user *user,
>        struct ipmi_addr *addr,
>        long msgid,
>        struct kernel_ipmi_msg *msg,
>        void *user_msg_data,
>        void *supplied_smi,
>        struct ipmi_recv_msg *supplied_recv,
>        int priority);
># 200 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>void ipmi_poll_interface(struct ipmi_user *user);
># 211 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>int ipmi_register_for_cmd(struct ipmi_user *user,
>     unsigned char netfn,
>     unsigned char cmd,
>     unsigned int chans);
>int ipmi_unregister_for_cmd(struct ipmi_user *user,
>       unsigned char netfn,
>       unsigned char cmd,
>       unsigned int chans);
># 246 "/usr/src/linux-5.14.21-150500.53/include/linux/ipmi.h"
>int ipmi_get_maintenance_mode(struct ipmi_user *user);
>int ipmi_set_maintenance_mode(struct ipmi_user *user, int mode);
>
>
>
>
>
>
>
>int ipmi_set_gets_events(struct ipmi_user *user, bool val);
>
>
>
>
>
>
>struct ipmi_smi_watcher {
> struct list_head link;
>
>
>
>
>
> struct module *owner;
>
>
>
>
>
>
>
> void (*new_smi)(int if_num, struct device *dev);
> void (*smi_gone)(int if_num);
>};
>
>int ipmi_smi_watcher_register(struct ipmi_smi_watcher *watcher);
>int ipmi_smi_watcher_unregister(struct ipmi_smi_watcher *watcher);
>
>
>
>
>
>
>
>unsigned int ipmi_addr_length(int addr_type);
>
>
>int ipmi_validate_addr(struct ipmi_addr *addr, int len);
>
>
>
>
>enum ipmi_addr_src {
> SI_INVALID = 0, SI_HOTMOD, SI_HARDCODED, SI_SPMI, SI_ACPI, SI_SMBIOS,
> SI_PCI, SI_DEVICETREE, SI_PLATFORM, SI_LAST
>};
>const char *ipmi_addr_src_to_str(enum ipmi_addr_src src);
>
>union ipmi_smi_info_union {
>
>
>
>
>
> struct {
>  acpi_handle acpi_handle;
> } acpi_info;
>
>};
>
>struct ipmi_smi_info {
> enum ipmi_addr_src addr_src;
>
>
>
>
>
> struct device *dev;
>
>
>
>
>
>
> union ipmi_smi_info_union addr_info;
>};
>
>
>extern int ipmi_get_smi_info(int if_num, struct ipmi_smi_info *data);
># 342 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
># 533 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-memdbg.h" 1
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-memdbg.h"
>void nv_memdbg_init(void);
>void nv_memdbg_add(void *addr, NvU64 size, const char *file, int line);
>void nv_memdbg_remove(void *addr, NvU64 size, const char *file, int line);
>void nv_memdbg_exit(void);
># 534 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *nv_vmalloc(unsigned long size)
>{
>
>
>
>    void *ptr = __vmalloc(size, ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
>
>    if (ptr)
>        ;
>    return ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_vfree(void *ptr, NvU32 size)
>{
>    ;
>    vfree(ptr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *nv_ioremap(NvU64 phys, NvU64 size)
>{
>    void *ptr = ioremap(phys, size);
>    if (ptr)
>        ;
>    return ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *nv_ioremap_nocache(NvU64 phys, NvU64 size)
>{
>
>
>
>    void *ptr = ioremap(phys, size);
>
>    if (ptr)
>        ;
>    return ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *nv_ioremap_cache(NvU64 phys, NvU64 size)
>{
>
>    void *ptr = ioremap_cache(phys, size);
>    if (ptr)
>        ;
>    return ptr;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *nv_ioremap_wc(NvU64 phys, NvU64 size)
>{
>
>    void *ptr = ioremap_wc(phys, size);
>    if (ptr)
>        ;
>    return ptr;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_iounmap(void *ptr, NvU64 size)
>{
>    ;
>    iounmap(ptr);
>}
># 639 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>extern NvBool nvos_is_chipset_io_coherent(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvUPtr nv_vmap(struct page **pages, NvU32 page_count,
>    NvBool cached)
>{
>    void *ptr;
>    pgprot_t prot = ((pgprot_t) { ((((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)|(((pteval_t)(1)) << 63)|(((pteval_t)(1)) << 6)| 0|(((pteval_t)(1)) << 8)) | (((pteval_t)(sme_me_mask)))) & __default_kernel_pte_mask) } );
>
>    prot = cached ? ((pgprot_t) { ((((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)|(((pteval_t)(1)) << 63)|(((pteval_t)(1)) << 6)| 0|(((pteval_t)(1)) << 8)) | (((pteval_t)(sme_me_mask)))) & __default_kernel_pte_mask) } ) : ((pgprot_t) { ((((((pteval_t)(1)) << 0)|(((pteval_t)(1)) << 1)| 0|(((pteval_t)(1)) << 5)|(((pteval_t)(1)) << 63)|(((pteval_t)(1)) << 6)| 0|(((pteval_t)(1)) << 8)| (cachemode2protval(_PAGE_CACHE_MODE_UC))) | (((pteval_t)(sme_me_mask)))) & __default_kernel_pte_mask) } );
>
>
>
>
>
>    ptr = vmap(pages, page_count, 0x00000004, prot);
>    if (ptr)
>        ;
>    return (NvUPtr)ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_vunmap(NvUPtr vaddr, NvU32 page_count)
>{
>    vunmap((void *)vaddr);
>    ;
>}
># 739 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) dma_addr_t nv_phys_to_dma(struct pci_dev *dev, NvU64 pa)
>{
>
>
>
>
>
>    return (dma_addr_t)pa;
>
>}
># 1037 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int nv_remap_page_range(struct vm_area_struct *vma,
>    unsigned long virt_addr, NvU64 phys_addr, NvU64 size, pgprot_t prot)
>{
>    int ret = -1;
># 1060 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>    {
>        ret = remap_pfn_range(vma, virt_addr, (phys_addr >> 12), size,
>            prot);
>    }
>
>
>
>
>
>
>
>    return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int nv_io_remap_page_range(struct vm_area_struct *vma,
>    NvU64 phys_addr, NvU64 size, NvU32 extra_prot)
>{
>    int ret = -1;
>
>    ret = nv_remap_page_range(vma, vma->vm_start, phys_addr, size,
>        ((pgprot_t) { (((vma->vm_page_prot).pgprot) | extra_prot) } ));
>
>
>
>
>    return ret;
>}
>
>
>
>extern void *nvidia_stack_t_cache;
># 1158 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *nv_kmem_cache_zalloc(struct kmem_cache *k, gfp_t flags)
>{
># 1175 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>    return kmem_cache_zalloc(k, flags);
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int nv_kmem_cache_alloc_stack(nvidia_stack_t **stack)
>{
>    nvidia_stack_t *sp = ((void *)0);
>
>    sp = kmem_cache_alloc(nvidia_stack_t_cache, ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
>    if (sp == ((void *)0))
>        return -12;
>    sp->size = sizeof(sp->stack);
>    sp->top = sp->stack + sp->size;
>
>    *stack = sp;
>    return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void nv_kmem_cache_free_stack(nvidia_stack_t *stack)
>{
>
>    kmem_cache_free(nvidia_stack_t_cache, stack);
>
>}
># 1218 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>typedef struct nvidia_pte_s {
>    NvU64 phys_addr;
>    unsigned long virt_addr;
>    NvU64 dma_addr;
>
>    unsigned int guest_pfn;
>
>    unsigned int page_count;
>} nvidia_pte_t;
>
>typedef struct nv_alloc_s {
>    struct nv_alloc_s *next;
>    struct pci_dev *dev;
>    atomic_t usage_count;
>    unsigned int flags;
>    unsigned int num_pages;
>    unsigned int order;
>    unsigned int size;
>    nvidia_pte_t **page_table;
>    unsigned int pid;
>    struct page **user_pages;
>    NvU64 guest_id;
>} nv_alloc_t;
># 1265 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvU32 nv_alloc_init_flags(int cached, int contiguous, int zeroed)
>{
>    NvU32 flags = ((cached)<<16);
>    flags |= (1<<0);
>    if (contiguous)
>        flags |= (1<<2);
>    if (zeroed)
>        flags |= (1<<4);
>
>
>
>
>    return flags;
>}
># 1288 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvBool nv_is_dma_direct(struct device *dev)
>{
>    NvBool is_direct = ((NvBool)(0 != 0));
>
>
>
>
>
>
>    return is_direct;
>}
># 1310 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvBool nv_dma_maps_swiotlb(struct pci_dev *dev)
>{
>    NvBool swiotlb_in_use = ((NvBool)(0 != 0));
># 1330 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>    const struct dma_map_ops *ops __attribute__ ((unused)) = get_dma_ops(&dev->dev);
># 1398 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>    return swiotlb_in_use;
>}
># 1412 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>typedef struct nv_dma_submap_s {
>    NvU32 page_count;
>    NvU32 sg_map_count;
>
>    struct sg_table sgt;
>
>
>
>} nv_dma_submap_t;
>
>typedef struct nv_dma_map_s {
>    struct page **pages;
>    NvU64 page_count;
>    NvBool contiguous;
>
>    union
>    {
>        struct
>        {
>            NvU32 submap_count;
>            nv_dma_submap_t *submaps;
>        } discontig;
>
>        struct
>        {
>            NvU64 dma_addr;
>        } contig;
>    } mapping;
>
>    struct pci_dev *dev;
>} nv_dma_map_t;
># 1513 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>typedef struct work_struct nv_task_t;
>
>typedef struct nv_ibmnpu_info nv_ibmnpu_info_t;
>
>typedef struct nv_work_s {
>    nv_task_t task;
>    void *data;
>} nv_work_t;
># 1550 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>typedef enum
>{
>    NV_DEV_STACK_TIMER,
>    NV_DEV_STACK_ISR,
>    NV_DEV_STACK_ISR_BH,
>    NV_DEV_STACK_ISR_BH_UNLOCKED,
>    NV_DEV_STACK_PCI_CFGCHK,
>    NV_DEV_STACK_COUNT
>} nvidia_linux_dev_stack_t;
>
>
>
>
>typedef struct nv_linux_state_s {
>    nv_state_t nv_state;
>    atomic_t usage_count;
>
>    struct pci_dev *dev;
>
>
>    nv_ibmnpu_info_t *npu;
>
>    nvidia_stack_t *sp[NV_DEV_STACK_COUNT];
>
>    char registry_keys[512];
>
>
>    struct tasklet_struct tasklet;
>    nv_work_t work;
>
>
>    struct nv_timer rc_timer;
>
>
>    struct semaphore ldata_lock;
>
>
>    struct proc_dir_entry *proc_dir;
>
>    NvU32 minor_num;
>    struct nv_linux_state_s *next;
>
>
>    struct drm_device *drm;
>
>
>    nv_kthread_q_t bottom_half_q;
>    nv_kthread_q_item_t bottom_half_q_item;
>
>
>    void *isr_bh_unlocked_mutex;
>
>    NvBool tce_bypass_enabled;
>
>    NvU64 numa_memblock_size;
>
>    struct {
>        struct backlight_device *dev;
>        NvU32 displayId;
>    } backlight;
>} nv_linux_state_t;
>
>extern nv_linux_state_t *nv_linux_devices;
># 1625 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>extern struct semaphore nv_linux_devices_lock;
># 1639 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>typedef struct
>{
>    acpi_handle dev_handle;
>    int dev_id;
>} nv_video_t;
>
>typedef struct
>{
>    nvidia_stack_t *sp;
>    struct acpi_device *device;
>    struct acpi_handle *handle;
>
>    nv_video_t pNvVideo[8];
>
>    int notify_handler_installed;
>    int default_display_mask;
>} nv_acpi_t;
># 1666 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>typedef struct nvidia_event
>{
>    struct nvidia_event *next;
>    nv_event_t event;
>} nvidia_event_t;
>
>typedef enum
>{
>    NV_FOPS_STACK_INDEX_MMAP,
>    NV_FOPS_STACK_INDEX_IOCTL,
>    NV_FOPS_STACK_INDEX_PROCFS,
>    NV_FOPS_STACK_INDEX_COUNT
>} nvidia_entry_point_index_t;
>
>typedef struct
>{
>    nvidia_stack_t *sp;
>    nvidia_stack_t *fops_sp[NV_FOPS_STACK_INDEX_COUNT];
>    struct semaphore fops_sp_lock[NV_FOPS_STACK_INDEX_COUNT];
>    nv_alloc_t *free_list;
>    void *nvptr;
>    void *proc_data;
>    void *data;
>    nvidia_event_t *event_head, *event_tail;
>
>
>    nv_fd_memdesc_t fd_memdesc;
>    int event_pending;
>    nv_spinlock_t fp_lock;
>    wait_queue_head_t waitqueue;
>    off_t off;
>    NvU32 minor_num;
>    NvHandle hExportedRmObject;
>    NvU32 *attached_gpus;
>    size_t num_attached_gpus;
>    nv_alloc_mapping_context_t mmap_context;
>} nv_file_private_t;
># 1730 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>        typedef atomic64_t nv_atomic_long_t;
># 1814 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>extern int nv_update_memory_types;
>
>extern NvU32 NVreg_EnableUserNUMAManagement;
>
>extern NvU32 NVreg_EnableIBMNPURelaxedOrderingMode;
># 1847 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>extern NvU64 __nv_supported_pte_mask;
>
>
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-proto.h" 1
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-proto.h"
>int nv_acpi_init (void);
>int nv_acpi_uninit (void);
>
>
>
>
>irqreturn_t nv_gvi_kern_isr (int, void *);
>
>
>
>
>
>void nv_gvi_kern_bh (struct work_struct *);
>
>
>
>int nv_gvi_kern_suspend (struct pci_dev *, pm_message_t);
>int nv_gvi_kern_resume (struct pci_dev *);
>
>
>int nv_register_chrdev (void *);
>void nv_unregister_chrdev (void *);
>
>NvU8 nv_find_pci_capability (struct pci_dev *, NvU8);
>void * nv_alloc_file_private (void);
>void nv_free_file_private (nv_file_private_t *);
>
>void nv_check_pci_config_space (nv_state_t *, NvS32);
>
>int nv_register_procfs (void);
>void nv_unregister_procfs (void);
>void nv_procfs_add_warning (const char *, const char *);
>int nv_procfs_add_gpu (nv_linux_state_t *);
>void nv_procfs_remove_gpu (nv_linux_state_t *);
>
>int nvidia_mmap (struct file *, struct vm_area_struct *);
>int nvidia_mmap_helper (nv_state_t *, nv_file_private_t *, nvidia_stack_t *, struct vm_area_struct *, void *);
>int nv_encode_caching (pgprot_t *, NvU32, NvU32);
>
>void nv_user_map_init (void);
>int nv_user_map_register (NvU64, NvU64);
>void nv_user_map_unregister (NvU64, NvU64);
>
>int nv_heap_create (void);
>void nv_heap_destroy (void);
>int nv_mem_pool_create (void);
>void nv_mem_pool_destroy (void);
>void * nv_mem_pool_alloc_pages (NvU32);
>void nv_mem_pool_free_pages (void *, NvU32);
>
>NvUPtr nv_vm_map_pages (struct page **, NvU32, NvBool);
>void nv_vm_unmap_pages (NvUPtr, NvU32);
>
>NV_STATUS nv_alloc_contig_pages (nv_state_t *, nv_alloc_t *);
>void nv_free_contig_pages (nv_alloc_t *);
>NV_STATUS nv_alloc_system_pages (nv_state_t *, nv_alloc_t *);
>void nv_free_system_pages (nv_alloc_t *);
>
>int nv_uvm_init (void);
>void nv_uvm_exit (void);
>void nv_uvm_notify_start_device (const NvU8 *uuid);
>void nv_uvm_notify_stop_device (const NvU8 *uuid);
>NV_STATUS nv_uvm_event_interrupt (const NvU8 *uuid);
>
>
>NvBool nvidia_get_gpuid_list (NvU32 *gpu_ids, NvU32 *gpu_count);
>int nvidia_dev_get (NvU32, nvidia_stack_t *);
>void nvidia_dev_put (NvU32, nvidia_stack_t *);
>int nvidia_dev_get_uuid (const NvU8 *, nvidia_stack_t *);
>void nvidia_dev_put_uuid (const NvU8 *, nvidia_stack_t *);
>int nvidia_dev_get_pci_info (const NvU8 *, struct pci_dev **, NvU64 *, NvU64 *);
>
>int nvidia_open (struct inode *, struct file *);
>int nvidia_close (struct inode *, struct file *);
>unsigned int nvidia_poll (struct file *, poll_table *);
>int nvidia_ioctl (struct inode *, struct file *, unsigned int, unsigned long);
>
>int nvidia_probe (struct pci_dev *, const struct pci_device_id *);
>void nvidia_remove (struct pci_dev *);
>
>int nvidia_suspend (struct pci_dev *, pm_message_t);
>int nvidia_resume (struct pci_dev *);
>
>void nvidia_modeset_suspend (NvU32 gpuId);
>void nvidia_modeset_resume (NvU32 gpuId);
>
>NV_STATUS nv_parse_per_device_option_string(nvidia_stack_t *sp);
>nv_linux_state_t * find_pci(NvU16 domain, NvU8 bus, NvU8 slot, NvU8 function);
>void nv_report_error(struct pci_dev *dev, NvU32 error_number, const char *format, va_list ap);
># 1851 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>extern nv_pci_info_t nv_assign_gpu_pci_info[32];
>extern NvU32 nv_assign_gpu_count;
># 1885 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvU64 nv_node_end_pfn(int nid)
>{
>
>    return pgdat_end_pfn((node_data[nid]));
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvU64 nv_pci_bus_address(nv_linux_state_t *nvl, NvU8 bar_index)
>{
>    NvU64 bus_addr = 0;
>
>    bus_addr = pci_bus_address(nvl->dev, bar_index);
>
>
>
>
>
>
>    return bus_addr;
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvBool nv_alloc_release(nv_file_private_t *nvfp, nv_alloc_t *at)
>{
>    { nv_printf(0x0, "NVRM: VM: %s:%d: 0x%p, %d page(s), count = %d, flags = 0x%08x, " "page_table = 0x%p\n", __FUNCTION__, 1916, at, at->num_pages, atomic_read(&(at->usage_count)), at->flags, at->page_table); };
>
>    if (atomic_dec_and_test(&(at->usage_count)))
>    {
>        atomic_inc(&(at->usage_count));
>
>        at->next = nvfp->free_list;
>        nvfp->free_list = at;
>        return ((NvBool)(0 == 0));
>    }
>
>    return ((NvBool)(0 != 0));
>}
># 1962 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvU64 nv_compress_nvlink_addr(NvU64 addr)
>{
>    NvU64 addr47 = addr;
># 1974 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>    return addr47;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) NvU64 nv_expand_nvlink_addr(NvU64 addr47)
>{
>    NvU64 addr = addr47;
># 1988 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h"
>    return addr;
>}
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h" 1
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h" 1
># 29 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_recursion.h" 1
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_recursion.h"
>enum {
>
> TRACE_FTRACE_BIT,
> TRACE_FTRACE_NMI_BIT,
> TRACE_FTRACE_IRQ_BIT,
> TRACE_FTRACE_SIRQ_BIT,
> TRACE_FTRACE_TRANSITION_BIT,
>
>
> TRACE_INTERNAL_BIT,
> TRACE_INTERNAL_NMI_BIT,
> TRACE_INTERNAL_IRQ_BIT,
> TRACE_INTERNAL_SIRQ_BIT,
> TRACE_INTERNAL_TRANSITION_BIT,
>
> TRACE_BRANCH_BIT,
>
>
>
>
>
>
>
> TRACE_IRQ_BIT,
>
>
> TRACE_GRAPH_BIT,
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_recursion.h"
> TRACE_GRAPH_DEPTH_START_BIT,
> TRACE_GRAPH_DEPTH_END_BIT,
>
>
>
>
>
>
> TRACE_GRAPH_NOTRACE_BIT,
>
>
> TRACE_RECORD_RECURSION_BIT,
>};
># 109 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_recursion.h"
>enum {
> TRACE_CTX_NMI,
> TRACE_CTX_IRQ,
> TRACE_CTX_SOFTIRQ,
> TRACE_CTX_NORMAL,
> TRACE_CTX_TRANSITION,
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int trace_get_context_bit(void)
>{
> unsigned long pc = preempt_count();
>
> if (!(pc & ((((1UL << (4))-1) << (((0 + 8) + 8) + 4)) | (((1UL << (4))-1) << ((0 + 8) + 8)) | (1UL << (0 + 8)))))
>  return TRACE_CTX_NORMAL;
> else
>  return pc & (((1UL << (4))-1) << (((0 + 8) + 8) + 4)) ? TRACE_CTX_NMI :
>   pc & (((1UL << (4))-1) << ((0 + 8) + 8)) ? TRACE_CTX_IRQ : TRACE_CTX_SOFTIRQ;
>}
># 142 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_recursion.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int trace_test_and_set_recursion(unsigned long ip, unsigned long pip,
>       int start)
>{
> unsigned int val = ({ do { extern void __compiletime_assert_364(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(get_current()->trace_recursion) == sizeof(char) || sizeof(get_current()->trace_recursion) == sizeof(short) || sizeof(get_current()->trace_recursion) == sizeof(int) || sizeof(get_current()->trace_recursion) == sizeof(long)) || sizeof(get_current()->trace_recursion) == sizeof(long long))) __compiletime_assert_364(); } while (0); (*(const volatile typeof( _Generic((get_current()->trace_recursion), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (get_current()->trace_recursion))) *)&(get_current()->trace_recursion)); });
> int bit;
>
> bit = trace_get_context_bit() + start;
> if (__builtin_expect(!!(val & (1 << bit)), 0)) {
>
>
>
>
>  bit = TRACE_CTX_TRANSITION + start;
>  if (val & (1 << bit)) {
>   do { } while (0);
>   return -1;
>  }
> }
>
> val |= 1 << bit;
> get_current()->trace_recursion = val;
> __asm__ __volatile__("": : :"memory");
>
> return bit;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void trace_clear_recursion(int bit)
>{
> __asm__ __volatile__("": : :"memory");
> do { (get_current())->trace_recursion &= ~(1<<(bit)); } while (0);
>}
># 183 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_recursion.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int ftrace_test_recursion_trylock(unsigned long ip,
>        unsigned long parent_ip)
>{
> return trace_test_and_set_recursion(ip, parent_ip, TRACE_FTRACE_BIT);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void ftrace_test_recursion_unlock(int bit)
>{
> trace_clear_recursion(bit);
>}
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_clock.h" 1
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_clock.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/trace_clock.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/trace_clock.h"
>extern u64 __attribute__((no_instrument_function)) trace_clock_x86_tsc(void);
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/trace_clock.h" 2
>
>extern u64 __attribute__((no_instrument_function)) trace_clock_local(void);
>extern u64 __attribute__((no_instrument_function)) trace_clock(void);
>extern u64 __attribute__((no_instrument_function)) trace_clock_jiffies(void);
>extern u64 __attribute__((no_instrument_function)) trace_clock_global(void);
>extern u64 __attribute__((no_instrument_function)) trace_clock_counter(void);
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/kallsyms.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/linux/kallsyms.h"
>struct cred;
>struct module;
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_kernel_inittext(unsigned long addr)
>{
> if (addr >= (unsigned long)_sinittext
>     && addr <= (unsigned long)_einittext)
>  return 1;
> return 0;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_kernel_text(unsigned long addr)
>{
> if ((addr >= (unsigned long)_stext && addr <= (unsigned long)_etext) ||
>     arch_is_kernel_text(addr))
>  return 1;
> return in_gate_area_no_mm(addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_kernel(unsigned long addr)
>{
> if (addr >= (unsigned long)_stext && addr <= (unsigned long)_end)
>  return 1;
> return in_gate_area_no_mm(addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int is_ksym_addr(unsigned long addr)
>{
> if (1)
>  return is_kernel(addr);
>
> return is_kernel_text(addr) || is_kernel_inittext(addr);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *dereference_symbol_descriptor(void *ptr)
>{
># 74 "/usr/src/linux-5.14.21-150500.53/include/linux/kallsyms.h"
> return ptr;
>}
>
>
>int kallsyms_on_each_symbol(int (*fn)(void *, const char *, struct module *,
>          unsigned long),
>       void *data);
>
>
>unsigned long kallsyms_lookup_name(const char *name);
>
>extern int kallsyms_lookup_size_offset(unsigned long addr,
>      unsigned long *symbolsize,
>      unsigned long *offset);
>
>
>const char *kallsyms_lookup(unsigned long addr,
>       unsigned long *symbolsize,
>       unsigned long *offset,
>       char **modname, char *namebuf);
>
>
>extern int sprint_symbol(char *buffer, unsigned long address);
>extern int sprint_symbol_build_id(char *buffer, unsigned long address);
>extern int sprint_symbol_no_offset(char *buffer, unsigned long address);
>extern int sprint_backtrace(char *buffer, unsigned long address);
>extern int sprint_backtrace_build_id(char *buffer, unsigned long address);
>
>int lookup_symbol_name(unsigned long addr, char *symname);
>int lookup_symbol_attrs(unsigned long addr, unsigned long *size, unsigned long *offset, char *modname, char *name);
>
>
>extern bool kallsyms_show_value(const struct cred *cred);
># 182 "/usr/src/linux-5.14.21-150500.53/include/linux/kallsyms.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void print_ip_sym(const char *loglvl, unsigned long ip)
>{
> printk("%s[<%px>] %pS\n", loglvl, (void *) ip, (void *) ip);
>}
># 13 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h" 2
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/pid_namespace.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/pid_namespace.h"
>struct fs_pin;
>
>struct pid_namespace {
> struct idr idr;
> struct callback_head rcu;
> unsigned int pid_allocated;
> struct task_struct *child_reaper;
> struct kmem_cache *pid_cachep;
> unsigned int level;
> struct pid_namespace *parent;
>
> struct fs_pin *bacct;
>
> struct user_namespace *user_ns;
> struct ucounts *ucounts;
> int reboot;
> struct ns_common ns;
>} __attribute__((__designated_init__));
>
>extern struct pid_namespace init_pid_ns;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct pid_namespace *get_pid_ns(struct pid_namespace *ns)
>{
> if (ns != &init_pid_ns)
>  refcount_inc(&ns->ns.count);
> return ns;
>}
>
>extern struct pid_namespace *copy_pid_ns(unsigned long flags,
> struct user_namespace *user_ns, struct pid_namespace *ns);
>extern void zap_pid_ns_processes(struct pid_namespace *pid_ns);
>extern int reboot_pid_ns(struct pid_namespace *pid_ns, int cmd);
>extern void put_pid_ns(struct pid_namespace *ns);
># 85 "/usr/src/linux-5.14.21-150500.53/include/linux/pid_namespace.h"
>extern struct pid_namespace *task_active_pid_ns(struct task_struct *tsk);
>void pidhash_init(void);
>void pid_idr_init(void);
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ptrace.h" 1
># 59 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/ptrace.h"
>struct ptrace_peeksiginfo_args {
> __u64 off;
> __u32 flags;
> __s32 nr;
>};
>
>
>
>
>
>
>
>struct seccomp_metadata {
> __u64 filter_off;
> __u64 flags;
>};
>
>
>
>
>
>
>
>struct ptrace_syscall_info {
> __u8 op;
> __u8 pad[3];
> __u32 arch;
> __u64 instruction_pointer;
> __u64 stack_pointer;
> union {
>  struct {
>   __u64 nr;
>   __u64 args[6];
>  } entry;
>  struct {
>   __s64 rval;
>   __u8 is_error;
>  } exit;
>  struct {
>   __u64 nr;
>   __u64 args[6];
>   __u32 ret_data;
>  } seccomp;
> };
>};
>
>
>
>struct ptrace_rseq_configuration {
> __u64 rseq_abi_pointer;
> __u32 rseq_abi_size;
> __u32 signature;
> __u32 flags;
> __u32 pad;
>};
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h" 2
>
>
>
>struct syscall_info {
> __u64 sp;
> struct seccomp_data data;
>};
>
>extern int ptrace_access_vm(struct task_struct *tsk, unsigned long addr,
>       void *buf, int len, unsigned int gup_flags);
># 56 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>extern long arch_ptrace(struct task_struct *child, long request,
>   unsigned long addr, unsigned long data);
>extern int ptrace_readdata(struct task_struct *tsk, unsigned long src, char *dst, int len);
>extern int ptrace_writedata(struct task_struct *tsk, char *src, unsigned long dst, int len);
>extern void ptrace_disable(struct task_struct *);
>extern int ptrace_request(struct task_struct *child, long request,
>     unsigned long addr, unsigned long data);
>extern void ptrace_notify(int exit_code);
>extern void __ptrace_link(struct task_struct *child,
>     struct task_struct *new_parent,
>     const struct cred *ptracer_cred);
>extern void __ptrace_unlink(struct task_struct *child);
>extern void exit_ptrace(struct task_struct *tracer, struct list_head *dead);
># 95 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>extern bool ptrace_may_access(struct task_struct *task, unsigned int mode);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ptrace_reparented(struct task_struct *child)
>{
> return !same_thread_group(child->real_parent, child->parent);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptrace_unlink(struct task_struct *child)
>{
> if (__builtin_expect(!!(child->ptrace), 0))
>  __ptrace_unlink(child);
>}
>
>int generic_ptrace_peekdata(struct task_struct *tsk, unsigned long addr,
>       unsigned long data);
>int generic_ptrace_pokedata(struct task_struct *tsk, unsigned long addr,
>       unsigned long data);
># 124 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct task_struct *ptrace_parent(struct task_struct *task)
>{
> if (__builtin_expect(!!(task->ptrace), 0))
>  return ({ typeof(*(task->parent)) *________p1 = (typeof(*(task->parent)) *)({ do { extern void __compiletime_assert_365(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((task->parent)) == sizeof(char) || sizeof((task->parent)) == sizeof(short) || sizeof((task->parent)) == sizeof(int) || sizeof((task->parent)) == sizeof(long)) || sizeof((task->parent)) == sizeof(long long))) __compiletime_assert_365(); } while (0); (*(const volatile typeof( _Generic(((task->parent)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((task->parent)))) *)&((task->parent))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(task->parent)) *)(________p1)); });
> return ((void *)0);
>}
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool ptrace_event_enabled(struct task_struct *task, int event)
>{
> return task->ptrace & (1 << (3 + (event)));
>}
># 155 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptrace_event(int event, unsigned long message)
>{
> if (__builtin_expect(!!(ptrace_event_enabled(get_current(), event)), 0)) {
>  get_current()->ptrace_message = message;
>  ptrace_notify((event << 8) | 5);
> } else if (event == 4) {
>
>  if ((get_current()->ptrace & (0x00000001|0x00010000)) == 0x00000001)
>   send_sig(5, get_current(), 0);
> }
>}
># 178 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptrace_event_pid(int event, struct pid *pid)
>{
>
>
>
>
>
>
> unsigned long message = 0;
> struct pid_namespace *ns;
>
> rcu_read_lock();
> ns = task_active_pid_ns(({ typeof(*(get_current()->parent)) *________p1 = (typeof(*(get_current()->parent)) *)({ do { extern void __compiletime_assert_366(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof((get_current()->parent)) == sizeof(char) || sizeof((get_current()->parent)) == sizeof(short) || sizeof((get_current()->parent)) == sizeof(int) || sizeof((get_current()->parent)) == sizeof(long)) || sizeof((get_current()->parent)) == sizeof(long long))) __compiletime_assert_366(); } while (0); (*(const volatile typeof( _Generic(((get_current()->parent)), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: ((get_current()->parent)))) *)&((get_current()->parent))); }); do { } while (0 && (!((0) || rcu_read_lock_held()))); ; ((typeof(*(get_current()->parent)) *)(________p1)); }));
> if (ns)
>  message = pid_nr_ns(pid, ns);
> rcu_read_unlock();
>
> ptrace_event(event, message);
>}
># 208 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptrace_init_task(struct task_struct *child, bool ptrace)
>{
> INIT_LIST_HEAD(&child->ptrace_entry);
> INIT_LIST_HEAD(&child->ptraced);
> child->jobctl = 0;
> child->ptrace = 0;
> child->parent = child->real_parent;
>
> if (__builtin_expect(!!(ptrace), 0) && get_current()->ptrace) {
>  child->ptrace = get_current()->ptrace;
>  __ptrace_link(child, get_current()->parent, get_current()->ptracer_cred);
>
>  if (child->ptrace & 0x00010000)
>   task_set_jobctl_pending(child, (1UL << 19));
>  else
>   sigaddset(&child->pending.signal, 19);
> }
> else
>  child->ptracer_cred = ((void *)0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void ptrace_release_task(struct task_struct *task)
>{
> do { if (__builtin_expect(!!(!list_empty(&task->ptraced)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"), "i" (237), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("367" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "367" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
> ptrace_unlink(task);
> do { if (__builtin_expect(!!(!list_empty(&task->ptrace_entry)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"), "i" (239), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("368" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "368" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
>}
># 313 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>extern void user_enable_single_step(struct task_struct *);
>extern void user_disable_single_step(struct task_struct *);
># 343 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>extern void user_enable_block_step(struct task_struct *);
>
>
>
>extern void user_single_step_report(struct pt_regs *regs);
># 417 "/usr/src/linux-5.14.21-150500.53/include/linux/ptrace.h"
>extern int task_current_syscall(struct task_struct *target, struct syscall_info *info);
>
>extern void sigaction_compat_abi(struct k_sigaction *act, struct k_sigaction *oact);
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h" 2
>
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ftrace.h" 1
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ftrace.h"
>extern atomic_t modifying_ftrace_code;
>extern void __fentry__(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long ftrace_call_adjust(unsigned long addr)
>{
>
>
>
>
> return addr;
>}
># 38 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ftrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_ftrace_set_direct_caller(struct pt_regs *regs, unsigned long addr)
>{
>
> regs->orig_ax = addr;
>}
>
>
>struct ftrace_regs {
> struct pt_regs regs;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct pt_regs *
>arch_ftrace_get_regs(struct ftrace_regs *fregs)
>{
>
> if (!fregs->regs.cs)
>  return ((void *)0);
> return &fregs->regs;
>}
>
>
>
>
>
>
>
>struct dyn_arch_ftrace {
>
>};
># 78 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ftrace.h"
>extern void set_ftrace_ops_ro(void);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_syscall_match_sym_name(const char *sym, const char *name)
>{
>
>
>
>
> return !strcmp(sym + 3, name + 3) ||
>  (!strncmp(sym, "__x64_", 6) && !strcmp(sym + 9, name + 3)) ||
>  (!strncmp(sym, "__ia32_", 7) && !strcmp(sym + 10, name + 3)) ||
>  (!strncmp(sym, "__do_sys", 8) && !strcmp(sym + 8, name + 3));
>}
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h" 1
># 15 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/socket.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/socket.h" 1
>
>
>
>
>
># 1 "./arch/x86/include/generated/uapi/asm/sockios.h" 1
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/sockios.h" 1
># 1 "./arch/x86/include/generated/uapi/asm/sockios.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/uapi/asm-generic/socket.h" 2
># 1 "./arch/x86/include/generated/uapi/asm/socket.h" 2
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sockios.h" 1
># 23 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sockios.h"
># 1 "./arch/x86/include/generated/uapi/asm/sockios.h" 1
># 24 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/sockios.h" 2
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/socket.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/socket.h"
>typedef unsigned short __kernel_sa_family_t;
>
>
>
>
>
>struct __kernel_sockaddr_storage {
> union {
>  struct {
>   __kernel_sa_family_t ss_family;
>
>   char __data[128 - sizeof(unsigned short)];
>
>
>  };
>  void *__align;
> };
>};
># 12 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h" 2
>
>struct file;
>struct pid;
>struct cred;
>struct socket;
>
>
>
>
>
>struct seq_file;
>extern void socket_seq_show(struct seq_file *seq);
>
>
>typedef __kernel_sa_family_t sa_family_t;
>
>
>
>
>
>struct sockaddr {
> sa_family_t sa_family;
> char sa_data[14];
>};
>
>struct linger {
> int l_onoff;
> int l_linger;
>};
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h"
>struct msghdr {
> void *msg_name;
> int msg_namelen;
> struct iov_iter msg_iter;
>
>
>
>
>
>
> union {
>  void *msg_control;
>  void *msg_control_user;
> };
> bool msg_control_is_user : 1;
> __kernel_size_t msg_controllen;
> unsigned int msg_flags;
> struct kiocb *msg_iocb;
>};
>
>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 cmsghdr {
> __kernel_size_t cmsg_len;
>        int cmsg_level;
>        int cmsg_type;
>};
># 141 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cmsghdr * __cmsg_nxthdr(void *__ctl, __kernel_size_t __size,
>            struct cmsghdr *__cmsg)
>{
> struct cmsghdr * __ptr;
>
> __ptr = (struct cmsghdr*)(((unsigned char *) __cmsg) + ( ((__cmsg->cmsg_len)+sizeof(long)-1) & ~(sizeof(long)-1) ));
> if ((unsigned long)((char*)(__ptr+1) - (char *) __ctl) > __size)
>  return (struct cmsghdr *)0;
>
> return __ptr;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct cmsghdr * cmsg_nxthdr (struct msghdr *__msg, struct cmsghdr *__cmsg)
>{
> return __cmsg_nxthdr(__msg->msg_control, __msg->msg_controllen, __cmsg);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) size_t msg_data_left(struct msghdr *msg)
>{
> return iov_iter_count(&msg->msg_iter);
>}
>
>
>
>
>
>
>
>struct ucred {
> __u32 pid;
> __u32 uid;
> __u32 gid;
>};
># 368 "/usr/src/linux-5.14.21-150500.53/include/linux/socket.h"
>extern int move_addr_to_kernel(void *uaddr, int ulen, struct __kernel_sockaddr_storage *kaddr);
>extern int put_cmsg(struct msghdr*, int level, int type, int len, void *data);
>
>struct timespec64;
>struct __kernel_timespec;
>struct old_timespec32;
>
>struct scm_timestamping_internal {
> struct timespec64 ts[3];
>};
>
>extern void put_cmsg_scm_timestamping64(struct msghdr *msg, struct scm_timestamping_internal *tss);
>extern void put_cmsg_scm_timestamping(struct msghdr *msg, struct scm_timestamping_internal *tss);
>
>
>
>
>extern long __sys_recvmsg(int fd, struct user_msghdr *msg,
>     unsigned int flags, bool forbid_cmsg_compat);
>extern long __sys_sendmsg(int fd, struct user_msghdr *msg,
>     unsigned int flags, bool forbid_cmsg_compat);
>extern int __sys_recvmmsg(int fd, struct mmsghdr *mmsg,
>     unsigned int vlen, unsigned int flags,
>     struct __kernel_timespec *timeout,
>     struct old_timespec32 *timeout32);
>extern int __sys_sendmmsg(int fd, struct mmsghdr *mmsg,
>     unsigned int vlen, unsigned int flags,
>     bool forbid_cmsg_compat);
>extern long __sys_sendmsg_sock(struct socket *sock, struct msghdr *msg,
>          unsigned int flags);
>extern long __sys_recvmsg_sock(struct socket *sock, struct msghdr *msg,
>          struct user_msghdr *umsg,
>          struct sockaddr *uaddr,
>          unsigned int flags);
>extern int sendmsg_copy_msghdr(struct msghdr *msg,
>          struct user_msghdr *umsg, unsigned flags,
>          struct iovec **iov);
>extern int recvmsg_copy_msghdr(struct msghdr *msg,
>          struct user_msghdr *umsg, unsigned flags,
>          struct sockaddr **uaddr,
>          struct iovec **iov);
>extern int __copy_msghdr_from_user(struct msghdr *kmsg,
>       struct user_msghdr *umsg,
>       struct sockaddr **save_addr,
>       struct iovec **uiov, size_t *nsegs);
>
>
>extern int __sys_recvfrom(int fd, void *ubuf, size_t size,
>     unsigned int flags, struct sockaddr *addr,
>     int *addr_len);
>extern int __sys_sendto(int fd, void *buff, size_t len,
>   unsigned int flags, struct sockaddr *addr,
>   int addr_len);
>extern int __sys_accept4_file(struct file *file, unsigned file_flags,
>   struct sockaddr *upeer_sockaddr,
>    int *upeer_addrlen, int flags,
>    unsigned long nofile);
>extern struct file *do_accept(struct file *file, unsigned file_flags,
>         struct sockaddr *upeer_sockaddr,
>         int *upeer_addrlen, int flags);
>extern int __sys_accept4(int fd, struct sockaddr *upeer_sockaddr,
>    int *upeer_addrlen, int flags);
>extern int __sys_socket(int family, int type, int protocol);
>extern int __sys_bind(int fd, struct sockaddr *umyaddr, int addrlen);
>extern int __sys_connect_file(struct file *file, struct __kernel_sockaddr_storage *addr,
>         int addrlen, int file_flags);
>extern int __sys_connect(int fd, struct sockaddr *uservaddr,
>    int addrlen);
>extern int __sys_listen(int fd, int backlog);
>extern int __sys_getsockname(int fd, struct sockaddr *usockaddr,
>        int *usockaddr_len);
>extern int __sys_getpeername(int fd, struct sockaddr *usockaddr,
>        int *usockaddr_len);
>extern int __sys_socketpair(int family, int type, int protocol,
>       int *usockvec);
>extern int __sys_shutdown_sock(struct socket *sock, int how);
>extern int __sys_shutdown(int fd, int how);
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h" 1
># 37 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/hdlc/ioctl.h" 1
># 40 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/hdlc/ioctl.h"
>typedef struct {
> unsigned int clock_rate;
> unsigned int clock_type;
> unsigned short loopback;
>} sync_serial_settings;
>
>typedef struct {
> unsigned int clock_rate;
> unsigned int clock_type;
> unsigned short loopback;
> unsigned int slot_map;
>} te1_settings;
>
>typedef struct {
> unsigned short encoding;
> unsigned short parity;
>} raw_hdlc_proto;
>
>typedef struct {
> unsigned int t391;
> unsigned int t392;
> unsigned int n391;
> unsigned int n392;
> unsigned int n393;
> unsigned short lmi;
> unsigned short 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 {
>    unsigned int interval;
>    unsigned int timeout;
>} cisco_proto;
>
>typedef struct {
> unsigned short dce;
> unsigned int modulo;
> unsigned int window;
> unsigned int t1;
> unsigned int t2;
> unsigned int n2;
>} x25_hdlc_proto;
># 38 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h" 2
># 82 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h"
>enum net_device_flags {
>
>
> IFF_UP = 1<<0,
> IFF_BROADCAST = 1<<1,
> IFF_DEBUG = 1<<2,
> IFF_LOOPBACK = 1<<3,
> IFF_POINTOPOINT = 1<<4,
> IFF_NOTRAILERS = 1<<5,
> IFF_RUNNING = 1<<6,
> IFF_NOARP = 1<<7,
> IFF_PROMISC = 1<<8,
> IFF_ALLMULTI = 1<<9,
> IFF_MASTER = 1<<10,
> IFF_SLAVE = 1<<11,
> IFF_MULTICAST = 1<<12,
> IFF_PORTSEL = 1<<13,
> IFF_AUTOMEDIA = 1<<14,
> IFF_DYNAMIC = 1<<15,
>
>
> IFF_LOWER_UP = 1<<16,
> IFF_DORMANT = 1<<17,
> IFF_ECHO = 1<<18,
>
>};
># 167 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h"
>enum {
> IF_OPER_UNKNOWN,
> IF_OPER_NOTPRESENT,
> IF_OPER_DOWN,
> IF_OPER_LOWERLAYERDOWN,
> IF_OPER_TESTING,
> IF_OPER_DORMANT,
> IF_OPER_UP,
>};
>
>
>enum {
> IF_LINK_MODE_DEFAULT,
> IF_LINK_MODE_DORMANT,
> IF_LINK_MODE_TESTING,
>};
># 196 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h"
>struct ifmap {
> unsigned long mem_start;
> unsigned long mem_end;
> unsigned short base_addr;
> unsigned char irq;
> unsigned char dma;
> unsigned char port;
>
>};
>
>
>struct if_settings {
> unsigned int type;
> unsigned int size;
> union {
>
>  raw_hdlc_proto *raw_hdlc;
>  cisco_proto *cisco;
>  fr_proto *fr;
>  fr_proto_pvc *fr_pvc;
>  fr_proto_pvc_info *fr_pvc_info;
>  x25_hdlc_proto *x25;
>
>
>  sync_serial_settings *sync;
>  te1_settings *te1;
> } ifs_ifsu;
>};
># 234 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h"
>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 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;
>};
># 286 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/if.h"
>struct ifconf {
> int ifc_len;
> union {
>  char *ifcu_buf;
>  struct ifreq *ifcu_req;
> } ifc_ifcu;
>};
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/aio_abi.h" 1
># 34 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/aio_abi.h"
>typedef __kernel_ulong_t aio_context_t;
>
>enum {
> IOCB_CMD_PREAD = 0,
> IOCB_CMD_PWRITE = 1,
> IOCB_CMD_FSYNC = 2,
> IOCB_CMD_FDSYNC = 3,
>
> IOCB_CMD_POLL = 5,
> IOCB_CMD_NOOP = 6,
> IOCB_CMD_PREADV = 7,
> IOCB_CMD_PWRITEV = 8,
>};
># 60 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/aio_abi.h"
>struct io_event {
> __u64 data;
> __u64 obj;
> __s64 res;
> __s64 res2;
>};
>
>
>
>
>
>
>
>struct iocb {
>
> __u64 aio_data;
>
>
> __u32 aio_key;
> __kernel_rwf_t aio_rw_flags;
># 88 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/aio_abi.h"
> __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;
>};
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h" 2
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/compat.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/compat.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h" 1
># 10 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/magic.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h" 2
># 19 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *task_stack_page(const struct task_struct *task)
>{
> return task->stack;
>}
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long *end_of_stack(const struct task_struct *task)
>{
>
>
>
> return task->stack;
>
>}
># 66 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *try_get_task_stack(struct task_struct *tsk)
>{
> return refcount_inc_not_zero(&tsk->stack_refcount) ?
>  task_stack_page(tsk) : ((void *)0);
>}
>
>extern void put_task_stack(struct task_struct *tsk);
># 85 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int object_is_on_stack(const void *obj)
>{
> void *stack = task_stack_page(get_current());
>
> return (obj >= stack) && (obj < (stack + (((1UL) << 12) << (2 + 0))));
>}
>
>extern void thread_stack_cache_init(void);
># 114 "/usr/src/linux-5.14.21-150500.53/include/linux/sched/task_stack.h"
>extern void set_task_stack_end_magic(struct task_struct *tsk);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kstack_end(void *addr)
>{
>
>
>
> return !(((unsigned long)addr+sizeof(void*)-1) & ((((1UL) << 12) << (2 + 0))-sizeof(void*)));
>}
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/compat.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/user32.h" 1
>
>
>
>
>
>
>
>struct user_i387_ia32_struct {
> u32 cwd;
> u32 swd;
> u32 twd;
> u32 fip;
> u32 fcs;
> u32 foo;
> u32 fos;
> u32 st_space[20];
>};
>
>
>struct user32_fxsr_struct {
> unsigned short cwd;
> unsigned short swd;
> unsigned short twd;
> unsigned short fop;
> int fip;
> int fcs;
> int foo;
> int fos;
> int mxcsr;
> int reserved;
> int st_space[32];
> int xmm_space[32];
> int padding[56];
>};
>
>struct user_regs_struct32 {
> __u32 ebx, ecx, edx, esi, edi, ebp, eax;
> unsigned short ds, __ds, es, __es;
> unsigned short fs, __fs, gs, __gs;
> __u32 orig_eax, eip;
> unsigned short cs, __cs;
> __u32 eflags, esp;
> unsigned short ss, __ss;
>};
>
>struct user32 {
>  struct user_regs_struct32 regs;
>  int u_fpvalid;
>
>  struct user_i387_ia32_struct i387;
>
>  __u32 u_tsize;
>  __u32 u_dsize;
>  __u32 u_ssize;
>  __u32 start_code;
>  __u32 start_stack;
>
>
>
>  __u32 signal;
>  int reserved;
>  __u32 u_ar0;
>
>  __u32 u_fpstate;
>  __u32 magic;
>  char u_comm[32];
>  int u_debugreg[8];
>};
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/compat.h" 2
>
>
>
>typedef u16 compat_mode_t;
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/compat.h" 1
>
>
>
>
>
>typedef u32 compat_size_t;
>typedef s32 compat_ssize_t;
>typedef s32 compat_clock_t;
>typedef s32 compat_pid_t;
>typedef u32 compat_ino_t;
>typedef s32 compat_off_t;
>typedef s64 compat_loff_t;
>typedef s32 compat_daddr_t;
>typedef s32 compat_timer_t;
>typedef s32 compat_key_t;
>typedef s16 compat_short_t;
>typedef s32 compat_int_t;
>typedef s32 compat_long_t;
>typedef u16 compat_ushort_t;
>typedef u32 compat_uint_t;
>typedef u32 compat_ulong_t;
>typedef u32 compat_uptr_t;
>typedef u32 compat_caddr_t;
>typedef u32 compat_aio_context_t;
>typedef u32 compat_old_sigset_t;
>
>
>typedef u32 __compat_uid32_t;
>typedef u32 __compat_gid32_t;
>
>
>
>
>
>
>
>typedef s64 __attribute__((aligned(4))) compat_s64;
>typedef u64 __attribute__((aligned(4))) compat_u64;
>
>
>
>
>
>
>typedef u32 compat_sigset_word;
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/compat.h" 2
>
>
>
>
>typedef u16 __compat_uid_t;
>typedef u16 __compat_gid_t;
>typedef u16 compat_dev_t;
>typedef u16 compat_nlink_t;
>typedef u16 compat_ipc_pid_t;
>typedef __kernel_fsid_t compat_fsid_t;
>
>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_flock {
> short l_type;
> short l_whence;
> compat_off_t l_start;
> compat_off_t l_len;
> compat_pid_t l_pid;
>};
># 69 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/compat.h"
>struct compat_flock64 {
> short l_type;
> short l_whence;
> compat_loff_t l_start;
> compat_loff_t l_len;
> compat_pid_t l_pid;
>} __attribute__((packed));
>
>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_ipc64_perm {
> compat_key_t key;
> __compat_uid32_t uid;
> __compat_gid32_t gid;
> __compat_uid32_t cuid;
> __compat_gid32_t cgid;
> unsigned short mode;
> unsigned short __pad1;
> unsigned short seq;
> unsigned short __pad2;
> compat_ulong_t unused1;
> compat_ulong_t unused2;
>};
>
>struct compat_semid64_ds {
> struct compat_ipc64_perm sem_perm;
> compat_ulong_t sem_otime;
> compat_ulong_t sem_otime_high;
> compat_ulong_t sem_ctime;
> compat_ulong_t sem_ctime_high;
> compat_ulong_t sem_nsems;
> compat_ulong_t __unused3;
> compat_ulong_t __unused4;
>};
>
>struct compat_msqid64_ds {
> struct compat_ipc64_perm msg_perm;
> compat_ulong_t msg_stime;
> compat_ulong_t msg_stime_high;
> compat_ulong_t msg_rtime;
> compat_ulong_t msg_rtime_high;
> compat_ulong_t msg_ctime;
> compat_ulong_t msg_ctime_high;
> compat_ulong_t msg_cbytes;
> compat_ulong_t msg_qnum;
> compat_ulong_t msg_qbytes;
> compat_pid_t msg_lspid;
> compat_pid_t msg_lrpid;
> compat_ulong_t __unused4;
> compat_ulong_t __unused5;
>};
>
>struct compat_shmid64_ds {
> struct compat_ipc64_perm shm_perm;
> compat_size_t shm_segsz;
> compat_ulong_t shm_atime;
> compat_ulong_t shm_atime_high;
> compat_ulong_t shm_dtime;
> compat_ulong_t shm_dtime_high;
> compat_ulong_t shm_ctime;
> compat_ulong_t shm_ctime_high;
> compat_pid_t shm_cpid;
> compat_pid_t shm_lpid;
> compat_ulong_t shm_nattch;
> compat_ulong_t __unused4;
> compat_ulong_t __unused5;
>};
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *arch_compat_alloc_user_space(long len)
>{
> compat_uptr_t sp = ({ unsigned long __ptr = (unsigned long)task_stack_page(get_current()); __ptr += (((1UL) << 12) << (2 + 0)) - 0; ((struct pt_regs *)__ptr) - 1; })->sp;
>
>
>
>
>
> sp -= 128;
>
> return (void *)((sp - len) & ~((__typeof__(sp - len))((16)-1)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool in_x32_syscall(void)
>{
>
>
>
>
> return false;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool in_32bit_syscall(void)
>{
> return (1 && ((struct thread_info *)get_current())->status & 0x0002) || in_x32_syscall();
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool in_compat_syscall(void)
>{
> return in_32bit_syscall();
>}
>
>
>
>
>struct compat_siginfo;
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h" 2
># 34 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/syscall_wrapper.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/syscall_wrapper.h"
>struct pt_regs;
>
>extern long __x64_sys_ni_syscall(const struct pt_regs *regs);
>extern long __ia32_sys_ni_syscall(const struct pt_regs *regs);
># 269 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/syscall_wrapper.h"
>long __x64_sys_getcpu(const struct pt_regs *regs);
>long __x64_sys_gettimeofday(const struct pt_regs *regs);
>long __x64_sys_time(const struct pt_regs *regs);
># 35 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h" 2
># 90 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
>struct compat_iovec {
> compat_uptr_t iov_base;
> compat_size_t iov_len;
>};
>
>
>
>
>
>typedef struct compat_sigaltstack {
> compat_uptr_t ss_sp;
> int ss_flags;
> compat_size_t ss_size;
>} compat_stack_t;
># 112 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
>typedef __compat_uid32_t compat_uid_t;
>typedef __compat_gid32_t compat_gid_t;
>
>struct compat_sel_arg_struct;
>struct rusage;
>
>struct old_itimerval32;
>
>struct compat_tms {
> compat_clock_t tms_utime;
> compat_clock_t tms_stime;
> compat_clock_t tms_cutime;
> compat_clock_t tms_cstime;
>};
>
>
>
>
>typedef struct {
> compat_sigset_word sig[(64 / 32)];
>} compat_sigset_t;
>
>
>int set_compat_user_sigmask(const compat_sigset_t *umask,
>       size_t sigsetsize);
>
>struct compat_sigaction {
>
> compat_uptr_t sa_handler;
> compat_ulong_t sa_flags;
>
>
>
>
>
> compat_uptr_t sa_restorer;
>
> compat_sigset_t sa_mask __attribute__((__packed__));
>};
>
>typedef union compat_sigval {
> compat_int_t sival_int;
> compat_uptr_t sival_ptr;
>} compat_sigval_t;
>
>typedef struct compat_siginfo {
> int si_signo;
>
> int si_errno;
> int si_code;
>
>
>
>
>
> union {
>  int _pad[128/sizeof(int) - 3];
>
>
>  struct {
>   compat_pid_t _pid;
>   __compat_uid32_t _uid;
>  } _kill;
>
>
>  struct {
>   compat_timer_t _tid;
>   int _overrun;
>   compat_sigval_t _sigval;
>  } _timer;
>
>
>  struct {
>   compat_pid_t _pid;
>   __compat_uid32_t _uid;
>   compat_sigval_t _sigval;
>  } _rt;
>
>
>  struct {
>   compat_pid_t _pid;
>   __compat_uid32_t _uid;
>   int _status;
>   compat_clock_t _utime;
>   compat_clock_t _stime;
>  } _sigchld;
># 211 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
>  struct {
>   compat_uptr_t _addr;
>
>
>   union {
>
>    int _trapno;
>
>
>
>
>    short int _addr_lsb;
>
>    struct {
>     char _dummy_bnd[(__alignof__(compat_uptr_t) < sizeof(short) ? sizeof(short) : __alignof__(compat_uptr_t))];
>     compat_uptr_t _lower;
>     compat_uptr_t _upper;
>    } _addr_bnd;
>
>    struct {
>     char _dummy_pkey[(__alignof__(compat_uptr_t) < sizeof(short) ? sizeof(short) : __alignof__(compat_uptr_t))];
>     u32 _pkey;
>    } _addr_pkey;
>
>    struct {
>     compat_ulong_t _data;
>     u32 _type;
>     u32 _flags;
>    } _perf;
>   };
>  } _sigfault;
>
>
>  struct {
>   compat_long_t _band;
>   int _fd;
>  } _sigpoll;
>
>  struct {
>   compat_uptr_t _call_addr;
>   int _syscall;
>   unsigned int _arch;
>  } _sigsys;
> } _sifields;
>} compat_siginfo_t;
>
>struct compat_rlimit {
> compat_ulong_t rlim_cur;
> compat_ulong_t rlim_max;
>};
>
>struct compat_rusage {
> struct old_timeval32 ru_utime;
> struct old_timeval32 ru_stime;
> compat_long_t ru_maxrss;
> compat_long_t ru_ixrss;
> compat_long_t ru_idrss;
> compat_long_t ru_isrss;
> compat_long_t ru_minflt;
> compat_long_t ru_majflt;
> compat_long_t ru_nswap;
> compat_long_t ru_inblock;
> compat_long_t ru_oublock;
> compat_long_t ru_msgsnd;
> compat_long_t ru_msgrcv;
> compat_long_t ru_nsignals;
> compat_long_t ru_nvcsw;
> compat_long_t ru_nivcsw;
>};
>
>extern int put_compat_rusage(const struct rusage *,
>        struct compat_rusage *);
>
>struct compat_siginfo;
>struct __compat_aio_sigset;
>
>struct compat_dirent {
> u32 d_ino;
> compat_off_t d_off;
> u16 d_reclen;
> char d_name[256];
>};
>
>struct compat_ustat {
> compat_daddr_t f_tfree;
> compat_ino_t f_tinode;
> char f_fname[6];
> char f_fpack[6];
>};
>
>
>
>typedef struct compat_sigevent {
> compat_sigval_t sigev_value;
> compat_int_t sigev_signo;
> compat_int_t sigev_notify;
> union {
>  compat_int_t _pad[((64/sizeof(int)) - 3)];
>  compat_int_t _tid;
>
>  struct {
>   compat_uptr_t _function;
>   compat_uptr_t _attribute;
>  } _sigev_thread;
> } _sigev_un;
>} compat_sigevent_t;
>
>struct compat_ifmap {
> compat_ulong_t mem_start;
> compat_ulong_t mem_end;
> unsigned short base_addr;
> unsigned char irq;
> unsigned char dma;
> unsigned char port;
>};
>
>struct compat_if_settings {
> unsigned int type;
> unsigned int size;
> compat_uptr_t ifs_ifsu;
>};
>
>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 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_ifconf {
> compat_int_t ifc_len;
> compat_caddr_t ifcbuf;
>};
>
>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_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_keyctl_kdf_params {
> compat_uptr_t hashname;
> compat_uptr_t otherinfo;
> __u32 otherinfolen;
> __u32 __spare[8];
>};
>
>struct compat_stat;
>struct compat_statfs;
>struct compat_statfs64;
>struct compat_old_linux_dirent;
>struct compat_linux_dirent;
>struct linux_dirent64;
>struct compat_msghdr;
>struct compat_mmsghdr;
>struct compat_sysinfo;
>struct compat_sysctl_args;
>struct compat_kexec_segment;
>struct compat_mq_attr;
>struct compat_msgbuf;
>
>
>
>
>
>long compat_get_bitmap(unsigned long *mask, const compat_ulong_t *umask,
>         unsigned long bitmap_size);
>long compat_put_bitmap(compat_ulong_t *umask, unsigned long *mask,
>         unsigned long bitmap_size);
>void copy_siginfo_to_external32(struct compat_siginfo *to,
>  const struct kernel_siginfo *from);
>int copy_siginfo_from_user32(kernel_siginfo_t *to,
>  const struct compat_siginfo *from);
>int __copy_siginfo_to_user32(struct compat_siginfo *to,
>  const kernel_siginfo_t *from);
>
>
>
>int get_compat_sigevent(struct sigevent *event,
>  const struct compat_sigevent *u_event);
>
>extern int get_compat_sigset(sigset_t *set, const compat_sigset_t *compat);
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int
>put_compat_sigset(compat_sigset_t *compat, const sigset_t *set,
>    unsigned int size)
>{
># 443 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
> return copy_to_user(compat, set, size) ? -14 : 0;
>
>}
># 514 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
>extern int compat_ptrace_request(struct task_struct *child,
>     compat_long_t request,
>     compat_ulong_t addr, compat_ulong_t data);
>
>extern long compat_arch_ptrace(struct task_struct *child, compat_long_t request,
>          compat_ulong_t addr, compat_ulong_t data);
>
>struct epoll_event;
>
>extern void *compat_alloc_user_space(unsigned long len);
>
>int compat_restore_altstack(const compat_stack_t *uss);
>int __compat_save_altstack(compat_stack_t *, unsigned long);
># 937 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct old_timeval32 ns_to_old_timeval32(s64 nsec)
>{
> struct __kernel_old_timeval tv;
> struct old_timeval32 ctv;
>
> tv = ns_to_kernel_old_timeval(nsec);
> ctv.tv_sec = tv.tv_sec;
> ctv.tv_usec = tv.tv_usec;
>
> return ctv;
>}
>
>
>
>
>
>
>
>int kcompat_sys_statfs64(const char * pathname, compat_size_t sz,
>       struct compat_statfs64 * buf);
>int kcompat_sys_fstatfs64(unsigned int fd, compat_size_t sz,
>     struct compat_statfs64 * buf);
># 996 "/usr/src/linux-5.14.21-150500.53/include/linux/compat.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void *compat_ptr(compat_uptr_t uptr)
>{
> return (void *)(unsigned long)uptr;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) compat_uptr_t ptr_to_compat(void *uptr)
>{
> return (u32)(unsigned long)uptr;
>}
># 100 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ftrace.h" 2
># 110 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/ftrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool arch_trace_is_compat_syscall(struct pt_regs *regs)
>{
> return in_32bit_syscall();
>}
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h" 2
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>void trace_init(void);
>void early_trace_init(void);
>
>
>
>
>
>struct module;
>struct ftrace_hash;
>struct ftrace_direct_func;
>
>
>
>const char *
>ftrace_mod_address_lookup(unsigned long addr, unsigned long *size,
>     unsigned long *off, char **modname, char *sym);
># 72 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>int ftrace_mod_get_kallsym(unsigned int symnum, unsigned long *value,
>      char *type, char *name,
>      char *module_name, int *exported);
># 86 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int ftrace_enabled;
>extern int
>ftrace_enable_sysctl(struct ctl_table *table, int write,
>       void *buffer, size_t *lenp, loff_t *ppos);
>
>struct ftrace_ops;
># 109 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct pt_regs *ftrace_get_regs(struct ftrace_regs *fregs)
>{
> if (!fregs)
>  return ((void *)0);
>
> return arch_ftrace_get_regs(fregs);
>}
>
>typedef void (*ftrace_func_t)(unsigned long ip, unsigned long parent_ip,
>         struct ftrace_ops *op, struct ftrace_regs *fregs);
>
>ftrace_func_t ftrace_ops_get_func(struct ftrace_ops *ops);
># 178 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>enum {
> FTRACE_OPS_FL_ENABLED = ((((1UL))) << (0)),
> FTRACE_OPS_FL_DYNAMIC = ((((1UL))) << (1)),
> FTRACE_OPS_FL_SAVE_REGS = ((((1UL))) << (2)),
> FTRACE_OPS_FL_SAVE_REGS_IF_SUPPORTED = ((((1UL))) << (3)),
> FTRACE_OPS_FL_RECURSION = ((((1UL))) << (4)),
> FTRACE_OPS_FL_STUB = ((((1UL))) << (5)),
> FTRACE_OPS_FL_INITIALIZED = ((((1UL))) << (6)),
> FTRACE_OPS_FL_DELETED = ((((1UL))) << (7)),
> FTRACE_OPS_FL_ADDING = ((((1UL))) << (8)),
> FTRACE_OPS_FL_REMOVING = ((((1UL))) << (9)),
> FTRACE_OPS_FL_MODIFYING = ((((1UL))) << (10)),
> FTRACE_OPS_FL_ALLOC_TRAMP = ((((1UL))) << (11)),
> FTRACE_OPS_FL_IPMODIFY = ((((1UL))) << (12)),
> FTRACE_OPS_FL_PID = ((((1UL))) << (13)),
> FTRACE_OPS_FL_RCU = ((((1UL))) << (14)),
> FTRACE_OPS_FL_TRACE_ARRAY = ((((1UL))) << (15)),
> FTRACE_OPS_FL_PERMANENT = ((((1UL))) << (16)),
> FTRACE_OPS_FL_DIRECT = ((((1UL))) << (17)),
>};
>
>
>
>struct ftrace_ops_hash {
> struct ftrace_hash *notrace_hash;
> struct ftrace_hash *filter_hash;
> struct mutex regex_lock;
>};
>
>void ftrace_free_init_mem(void);
>void ftrace_free_mem(struct module *mod, void *start, void *end);
># 225 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>struct ftrace_ops {
> ftrace_func_t func;
> struct ftrace_ops *next;
> unsigned long flags;
> void *private;
> ftrace_func_t saved_func;
>
> struct ftrace_ops_hash local_hash;
> struct ftrace_ops_hash *func_hash;
> struct ftrace_ops_hash old_hash;
> unsigned long trampoline;
> unsigned long trampoline_size;
> struct list_head list;
>
>};
>
>extern struct ftrace_ops *ftrace_ops_list;
>extern struct ftrace_ops ftrace_list_end;
># 267 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>enum ftrace_tracing_type_t {
> FTRACE_TYPE_ENTER = 0,
> FTRACE_TYPE_RETURN,
>};
>
>
>extern enum ftrace_tracing_type_t ftrace_tracing_type;
># 282 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>int register_ftrace_function(struct ftrace_ops *ops);
>int unregister_ftrace_function(struct ftrace_ops *ops);
>
>extern void ftrace_stub(unsigned long a0, unsigned long a1,
>   struct ftrace_ops *op, struct ftrace_regs *fregs);
>
>
>int ftrace_lookup_symbols(const char **sorted_syms, size_t cnt, unsigned long *addrs);
># 306 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>struct ftrace_func_entry {
> struct hlist_node hlist;
> unsigned long ip;
> unsigned long direct;
>};
>
>struct dyn_ftrace;
>
>
>extern int ftrace_direct_func_count;
>int register_ftrace_direct(unsigned long ip, unsigned long addr);
>int unregister_ftrace_direct(unsigned long ip, unsigned long addr);
>int modify_ftrace_direct(unsigned long ip, unsigned long old_addr, unsigned long new_addr);
>struct ftrace_direct_func *ftrace_find_direct_func(unsigned long addr);
>int ftrace_modify_direct_caller(struct ftrace_func_entry *entry,
>    struct dyn_ftrace *rec,
>    unsigned long old_addr,
>    unsigned long new_addr);
>unsigned long ftrace_find_rec_direct(unsigned long ip);
># 377 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int stack_tracer_enabled;
>
>int stack_trace_sysctl(struct ctl_table *table, int write, void *buffer,
>         size_t *lenp, loff_t *ppos);
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_disable_stack_tracer; extern __attribute__((section(".data..percpu" ""))) __typeof__(int) disable_stack_tracer;
># 396 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void stack_tracer_disable(void)
>{
>
> if (0)
>  ({ int __ret_warn_on = !!(!preempt_count() || !({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); })); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"), "i" (400), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("369" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "369" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> do { do { const void *__vpp_verify = (typeof((&(disable_stack_tracer)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(disable_stack_tracer)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) 1) & 0xff)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) 1) & 0xffff)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) 1) & 0xffffffff)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(1) && ((1) == 1 || (1) == -1)) ? (int)(1) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (1); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u64 pto_val__ = ((u64)(1)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (1); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void stack_tracer_enable(void)
>{
> if (0)
>  ({ int __ret_warn_on = !!(!preempt_count() || !({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); })); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"), "i" (413), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("370" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "370" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
> do { do { const void *__vpp_verify = (typeof((&(disable_stack_tracer)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(disable_stack_tracer)) { case 1: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(disable_stack_tracer))(1)) && ((-(typeof(disable_stack_tracer))(1)) == 1 || (-(typeof(disable_stack_tracer))(1)) == -1)) ? (int)(-(typeof(disable_stack_tracer))(1)) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "b " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u8 pto_val__ = ((u8)(((unsigned long) -(typeof(disable_stack_tracer))(1)) & 0xff)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pto_tmp__; } asm volatile("add" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "qi" (pto_val__)); } while (0); } while (0);break; case 2: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(disable_stack_tracer))(1)) && ((-(typeof(disable_stack_tracer))(1)) == 1 || (-(typeof(disable_stack_tracer))(1)) == -1)) ? (int)(-(typeof(disable_stack_tracer))(1)) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "w " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u16 pto_val__ = ((u16)(((unsigned long) -(typeof(disable_stack_tracer))(1)) & 0xffff)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pto_tmp__; } asm volatile("add" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 4: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(disable_stack_tracer))(1)) && ((-(typeof(disable_stack_tracer))(1)) == 1 || (-(typeof(disable_stack_tracer))(1)) == -1)) ? (int)(-(typeof(disable_stack_tracer))(1)) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "l " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u32 pto_val__ = ((u32)(((unsigned long) -(typeof(disable_stack_tracer))(1)) & 0xffffffff)); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pto_tmp__; } asm volatile("add" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "ri" (pto_val__)); } while (0); } while (0);break; case 8: do { const int pao_ID__ = (__builtin_constant_p(-(typeof(disable_stack_tracer))(1)) && ((-(typeof(disable_stack_tracer))(1)) == 1 || (-(typeof(disable_stack_tracer))(1)) == -1)) ? (int)(-(typeof(disable_stack_tracer))(1)) : 0; if (0) { typeof((disable_stack_tracer)) pao_tmp__; pao_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pao_tmp__; } if (pao_ID__ == 1) ({ asm volatile ("inc" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else if (pao_ID__ == -1) ({ asm volatile ("dec" "q " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer))); }); else do { u64 pto_val__ = ((u64)(-(typeof(disable_stack_tracer))(1))); if (0) { typeof((disable_stack_tracer)) pto_tmp__; pto_tmp__ = (-(typeof(disable_stack_tracer))(1)); (void)pto_tmp__; } asm volatile("add" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((disable_stack_tracer)) : [val] "re" (pto_val__)); } while (0); } while (0);break; default: __bad_size_call_parameter();break; } } while (0);
>}
>
>
>
>
>
>
>
>int ftrace_arch_code_modify_prepare(void);
>int ftrace_arch_code_modify_post_process(void);
>
>enum ftrace_bug_type {
> FTRACE_BUG_UNKNOWN,
> FTRACE_BUG_INIT,
> FTRACE_BUG_NOP,
> FTRACE_BUG_CALL,
> FTRACE_BUG_UPDATE,
>};
>extern enum ftrace_bug_type ftrace_bug_type;
>
>
>
>
>
>extern const void *ftrace_expected;
>
>void ftrace_bug(int err, struct dyn_ftrace *rec);
>
>struct seq_file;
>
>extern int ftrace_text_reserved(const void *start, const void *end);
>
>struct ftrace_ops *ftrace_ops_trampoline(unsigned long addr);
>
>bool is_ftrace_trampoline(unsigned long addr);
># 471 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>enum {
> FTRACE_FL_ENABLED = (1UL << 31),
> FTRACE_FL_REGS = (1UL << 30),
> FTRACE_FL_REGS_EN = (1UL << 29),
> FTRACE_FL_TRAMP = (1UL << 28),
> FTRACE_FL_TRAMP_EN = (1UL << 27),
> FTRACE_FL_IPMODIFY = (1UL << 26),
> FTRACE_FL_DISABLED = (1UL << 25),
> FTRACE_FL_DIRECT = (1UL << 24),
> FTRACE_FL_DIRECT_EN = (1UL << 23),
>};
>
>
>
>
>
>
>struct dyn_ftrace {
> unsigned long ip;
> unsigned long flags;
> struct dyn_arch_ftrace arch;
>};
>
>int ftrace_set_filter_ip(struct ftrace_ops *ops, unsigned long ip,
>    int remove, int reset);
>int ftrace_set_filter_ips(struct ftrace_ops *ops, unsigned long *ips,
>     unsigned int cnt, int remove, int reset);
>int ftrace_set_filter(struct ftrace_ops *ops, unsigned char *buf,
>         int len, int reset);
>int ftrace_set_notrace(struct ftrace_ops *ops, unsigned char *buf,
>   int len, int reset);
>void ftrace_set_global_filter(unsigned char *buf, int len, int reset);
>void ftrace_set_global_notrace(unsigned char *buf, int len, int reset);
>void ftrace_free_filter(struct ftrace_ops *ops);
>void ftrace_ops_set_global_filter(struct ftrace_ops *ops);
>
>enum {
> FTRACE_UPDATE_CALLS = (1 << 0),
> FTRACE_DISABLE_CALLS = (1 << 1),
> FTRACE_UPDATE_TRACE_FUNC = (1 << 2),
> FTRACE_START_FUNC_RET = (1 << 3),
> FTRACE_STOP_FUNC_RET = (1 << 4),
> FTRACE_MAY_SLEEP = (1 << 5),
>};
># 527 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>enum {
> FTRACE_UPDATE_IGNORE,
> FTRACE_UPDATE_MAKE_CALL,
> FTRACE_UPDATE_MODIFY_CALL,
> FTRACE_UPDATE_MAKE_NOP,
>};
>
>enum {
> FTRACE_ITER_FILTER = (1 << 0),
> FTRACE_ITER_NOTRACE = (1 << 1),
> FTRACE_ITER_PRINTALL = (1 << 2),
> FTRACE_ITER_DO_PROBES = (1 << 3),
> FTRACE_ITER_PROBE = (1 << 4),
> FTRACE_ITER_MOD = (1 << 5),
> FTRACE_ITER_ENABLED = (1 << 6),
>};
>
>void arch_ftrace_update_code(int command);
>void arch_ftrace_update_trampoline(struct ftrace_ops *ops);
>void *arch_ftrace_trampoline_func(struct ftrace_ops *ops, struct dyn_ftrace *rec);
>void arch_ftrace_trampoline_free(struct ftrace_ops *ops);
>
>struct ftrace_rec_iter;
>
>struct ftrace_rec_iter *ftrace_rec_iter_start(void);
>struct ftrace_rec_iter *ftrace_rec_iter_next(struct ftrace_rec_iter *iter);
>struct dyn_ftrace *ftrace_rec_iter_record(struct ftrace_rec_iter *iter);
>
>
>
>
>
>
>
>int ftrace_update_record(struct dyn_ftrace *rec, bool enable);
>int ftrace_test_record(struct dyn_ftrace *rec, bool enable);
>void ftrace_run_stop_machine(int command);
>unsigned long ftrace_location(unsigned long ip);
>unsigned long ftrace_location_range(unsigned long start, unsigned long end);
>unsigned long ftrace_get_addr_new(struct dyn_ftrace *rec);
>unsigned long ftrace_get_addr_curr(struct dyn_ftrace *rec);
>
>extern ftrace_func_t ftrace_trace_function;
>
>int ftrace_regex_open(struct ftrace_ops *ops, int flag,
>    struct inode *inode, struct file *file);
>ssize_t ftrace_filter_write(struct file *file, const char *ubuf,
>       size_t cnt, loff_t *ppos);
>ssize_t ftrace_notrace_write(struct file *file, const char *ubuf,
>        size_t cnt, loff_t *ppos);
>int ftrace_regex_release(struct inode *inode, struct file *file);
>
>void __attribute__((__section__(".init.text"))) __attribute__((__cold__))
>ftrace_set_early_filter(struct ftrace_ops *ops, char *buf, int enable);
>
>
>extern int ftrace_ip_converted(unsigned long ip);
>extern int ftrace_dyn_arch_init(void);
>extern void ftrace_replace_code(int enable);
>extern int ftrace_update_ftrace_func(ftrace_func_t func);
>extern void ftrace_caller(void);
>extern void ftrace_regs_caller(void);
>extern void ftrace_call(void);
>extern void ftrace_regs_call(void);
>extern void mcount_call(void);
>
>void ftrace_modify_all_code(int command);
># 622 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern void ftrace_graph_caller(void);
>extern int ftrace_enable_ftrace_graph_caller(void);
>extern int ftrace_disable_ftrace_graph_caller(void);
># 651 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int ftrace_make_nop(struct module *mod,
>      struct dyn_ftrace *rec, unsigned long addr);
># 677 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int ftrace_init_nop(struct module *mod, struct dyn_ftrace *rec)
>{
> return ftrace_make_nop(mod, rec, ((unsigned long)(__fentry__)));
>}
># 703 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int ftrace_make_call(struct dyn_ftrace *rec, unsigned long addr);
># 727 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int ftrace_modify_call(struct dyn_ftrace *rec, unsigned long old_addr,
>         unsigned long addr);
># 739 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int ftrace_arch_read_dyn_info(char *buf, int size);
>
>extern int skip_trace(unsigned long ip);
>extern void ftrace_module_init(struct module *mod);
>extern void ftrace_module_enable(struct module *mod);
>extern void ftrace_release_mod(struct module *mod);
>
>extern void ftrace_disable_daemon(void);
>extern void ftrace_enable_daemon(void);
># 792 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>void ftrace_kill(void);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void tracer_disable(void)
>{
>
> ftrace_enabled = 0;
>
>}
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int __ftrace_enabled_save(void)
>{
>
> int saved_ftrace_enabled = ftrace_enabled;
> ftrace_enabled = 0;
> return saved_ftrace_enabled;
>
>
>
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __ftrace_enabled_restore(int enabled)
>{
>
> ftrace_enabled = enabled;
>
>}
># 846 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) unsigned long get_lock_parent_ip(void)
>{
> unsigned long addr = ((unsigned long)__builtin_return_address(0));
>
> if (!in_lock_functions(addr))
>  return addr;
> addr = ((unsigned long)0UL);
> if (!in_lock_functions(addr))
>  return addr;
> return ((unsigned long)0UL);
>}
># 871 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern void ftrace_init(void);
># 886 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>struct ftrace_graph_ent {
> unsigned long func;
> int depth;
>} __attribute__((__packed__));
>
>
>
>
>
>
>struct ftrace_graph_ret {
> unsigned long func;
> int depth;
>
> unsigned int overrun;
> unsigned long long calltime;
> unsigned long long rettime;
>} __attribute__((__packed__));
>
>
>typedef void (*trace_func_graph_ret_t)(struct ftrace_graph_ret *);
>typedef int (*trace_func_graph_ent_t)(struct ftrace_graph_ent *);
>
>extern int ftrace_graph_entry_stub(struct ftrace_graph_ent *trace);
>
>
>
>struct fgraph_ops {
> trace_func_graph_ent_t entryfunc;
> trace_func_graph_ret_t retfunc;
>};
>
>
>
>
>
>
>struct ftrace_ret_stack {
> unsigned long ret;
> unsigned long func;
> unsigned long long calltime;
>
> unsigned long long subtime;
>
>
>
>
>
> unsigned long *retp;
>
>};
>
>
>
>
>
>
>extern void return_to_handler(void);
>
>extern int
>function_graph_enter(unsigned long ret, unsigned long func,
>       unsigned long frame_pointer, unsigned long *retp);
>
>struct ftrace_ret_stack *
>ftrace_graph_get_ret_stack(struct task_struct *task, int idx);
>
>unsigned long ftrace_graph_ret_addr(struct task_struct *task, int *idx,
>        unsigned long ret, unsigned long *retp);
># 965 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>extern int register_ftrace_graph(struct fgraph_ops *ops);
>extern void unregister_ftrace_graph(struct fgraph_ops *ops);
>
>extern bool ftrace_graph_is_dead(void);
>extern void ftrace_graph_stop(void);
>
>
>extern trace_func_graph_ret_t ftrace_graph_return;
>extern trace_func_graph_ent_t ftrace_graph_entry;
>
>extern void ftrace_graph_init_task(struct task_struct *t);
>extern void ftrace_graph_exit_task(struct task_struct *t);
>extern void ftrace_graph_init_idle_task(struct task_struct *t, int cpu);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void pause_graph_tracing(void)
>{
> atomic_inc(&get_current()->tracing_graph_pause);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unpause_graph_tracing(void)
>{
> atomic_dec(&get_current()->tracing_graph_pause);
>}
># 1014 "/usr/src/linux-5.14.21-150500.53/include/linux/ftrace.h"
>enum {
> TSK_TRACE_FL_TRACE_BIT = 0,
> TSK_TRACE_FL_GRAPH_BIT = 1,
>};
>enum {
> TSK_TRACE_FL_TRACE = 1 << TSK_TRACE_FL_TRACE_BIT,
> TSK_TRACE_FL_GRAPH = 1 << TSK_TRACE_FL_GRAPH_BIT,
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_tsk_trace_trace(struct task_struct *tsk)
>{
> set_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_tsk_trace_trace(struct task_struct *tsk)
>{
> clear_bit(TSK_TRACE_FL_TRACE_BIT, &tsk->trace);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_tsk_trace_trace(struct task_struct *tsk)
>{
> return tsk->trace & TSK_TRACE_FL_TRACE;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void set_tsk_trace_graph(struct task_struct *tsk)
>{
> set_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void clear_tsk_trace_graph(struct task_struct *tsk)
>{
> clear_bit(TSK_TRACE_FL_GRAPH_BIT, &tsk->trace);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int test_tsk_trace_graph(struct task_struct *tsk)
>{
> return tsk->trace & TSK_TRACE_FL_GRAPH;
>}
>
>enum ftrace_dump_mode;
>
>extern enum ftrace_dump_mode ftrace_dump_on_oops;
>extern int tracepoint_printk;
>
>extern void disable_trace_on_warning(void);
>extern int __disable_trace_on_warning;
>
>int tracepoint_printk_sysctl(struct ctl_table *table, int write,
>        void *buffer, size_t *lenp, loff_t *ppos);
>
>
>
>
>
>
>
>unsigned long arch_syscall_addr(int nr);
># 30 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/freelist.h" 1
># 18 "/usr/src/linux-5.14.21-150500.53/include/linux/freelist.h"
>struct freelist_node {
> atomic_t refs;
> struct freelist_node *next;
>};
>
>struct freelist_head {
> struct freelist_node *head;
>};
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __freelist_add(struct freelist_node *node, struct freelist_head *list)
>{
># 46 "/usr/src/linux-5.14.21-150500.53/include/linux/freelist.h"
> struct freelist_node *head = ({ do { extern void __compiletime_assert_371(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(list->head) == sizeof(char) || sizeof(list->head) == sizeof(short) || sizeof(list->head) == sizeof(int) || sizeof(list->head) == sizeof(long)) || sizeof(list->head) == sizeof(long long))) __compiletime_assert_371(); } while (0); (*(const volatile typeof( _Generic((list->head), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (list->head))) *)&(list->head)); });
>
> for (;;) {
>  do { do { extern void __compiletime_assert_372(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(node->next) == sizeof(char) || sizeof(node->next) == sizeof(short) || sizeof(node->next) == sizeof(int) || sizeof(node->next) == sizeof(long)) || sizeof(node->next) == sizeof(long long))) __compiletime_assert_372(); } while (0); do { *(volatile typeof(node->next) *)&(node->next) = (head); } while (0); } while (0);
>  atomic_set_release(&node->refs, 1);
>
>  if (!({ typeof(&list->head) __ai_ptr = (&list->head); typeof(&head) __ai_oldp = (&head); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); instrument_atomic_write(__ai_oldp, sizeof(*__ai_oldp)); ({ bool success; __typeof__(((__ai_ptr))) _old = (__typeof__(((__ai_ptr))))(((__ai_oldp))); __typeof__(*(((__ai_ptr)))) __old = *_old; __typeof__(*(((__ai_ptr)))) __new = (((node))); switch ((sizeof(*(__ai_ptr)))) { case 1: { volatile u8 *__ptr = (volatile u8 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgb %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "q" (__new) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgw %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgl %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgq %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } default: __cmpxchg_wrong_size(); } if (__builtin_expect(!!(!success), 0)) *_old = __old; __builtin_expect(!!(success), 1); }); })) {
>
>
>
>
>   if (atomic_fetch_add_release(0x80000000 - 1, &node->refs) == 1)
>    continue;
>  }
>  return;
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void freelist_add(struct freelist_node *node, struct freelist_head *list)
>{
>
>
>
>
> if (!atomic_fetch_add_release(0x80000000, &node->refs)) {
>
>
>
>
>  __freelist_add(node, list);
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct freelist_node *freelist_try_get(struct freelist_head *list)
>{
> struct freelist_node *prev, *next, *head = ({ typeof(*&list->head) ___p1 = ({ do { extern void __compiletime_assert_373(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&list->head) == sizeof(char) || sizeof(*&list->head) == sizeof(short) || sizeof(*&list->head) == sizeof(int) || sizeof(*&list->head) == sizeof(long)) || sizeof(*&list->head) == sizeof(long long))) __compiletime_assert_373(); } while (0); (*(const volatile typeof( _Generic((*&list->head), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&list->head))) *)&(*&list->head)); }); do { extern void __compiletime_assert_374(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&list->head) == sizeof(char) || sizeof(*&list->head) == sizeof(short) || sizeof(*&list->head) == sizeof(int) || sizeof(*&list->head) == sizeof(long)))) __compiletime_assert_374(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
> unsigned int refs;
>
> while (head) {
>  prev = head;
>  refs = atomic_read(&head->refs);
>  if ((refs & 0x7FFFFFFF) == 0 ||
>      !atomic_try_cmpxchg_acquire(&head->refs, &refs, refs+1)) {
>   head = ({ typeof(*&list->head) ___p1 = ({ do { extern void __compiletime_assert_375(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(*&list->head) == sizeof(char) || sizeof(*&list->head) == sizeof(short) || sizeof(*&list->head) == sizeof(int) || sizeof(*&list->head) == sizeof(long)) || sizeof(*&list->head) == sizeof(long long))) __compiletime_assert_375(); } while (0); (*(const volatile typeof( _Generic((*&list->head), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (*&list->head))) *)&(*&list->head)); }); do { extern void __compiletime_assert_376(void) __attribute__((__error__("Need native word sized stores/loads for atomicity."))); if (!((sizeof(*&list->head) == sizeof(char) || sizeof(*&list->head) == sizeof(short) || sizeof(*&list->head) == sizeof(int) || sizeof(*&list->head) == sizeof(long)))) __compiletime_assert_376(); } while (0); __asm__ __volatile__("": : :"memory"); ___p1; });
>   continue;
>  }
>
>
>
>
>
>
>  next = ({ do { extern void __compiletime_assert_377(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(head->next) == sizeof(char) || sizeof(head->next) == sizeof(short) || sizeof(head->next) == sizeof(int) || sizeof(head->next) == sizeof(long)) || sizeof(head->next) == sizeof(long long))) __compiletime_assert_377(); } while (0); (*(const volatile typeof( _Generic((head->next), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (head->next))) *)&(head->next)); });
>  if (({ typeof(&list->head) __ai_ptr = (&list->head); typeof(&head) __ai_oldp = (&head); instrument_atomic_write(__ai_ptr, sizeof(*__ai_ptr)); instrument_atomic_write(__ai_oldp, sizeof(*__ai_oldp)); ({ bool success; __typeof__(((__ai_ptr))) _old = (__typeof__(((__ai_ptr))))(((__ai_oldp))); __typeof__(*(((__ai_ptr)))) __old = *_old; __typeof__(*(((__ai_ptr)))) __new = (((next))); switch ((sizeof(*(__ai_ptr)))) { case 1: { volatile u8 *__ptr = (volatile u8 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgb %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "q" (__new) : "memory"); break; } case 2: { volatile u16 *__ptr = (volatile u16 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgw %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 4: { volatile u32 *__ptr = (volatile u32 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgl %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } case 8: { volatile u64 *__ptr = (volatile u64 *)(((__ai_ptr))); asm volatile(".pushsection .smp_locks,\"a\"\n" ".balign 4\n" ".long 671f - .\n" ".popsection\n" "671:" "\n\tlock; " "cmpxchgq %[new], %[ptr]" "\n\t/* output condition code " "z" "*/\n" : "=@cc" "z" (success), [ptr] "+m" (*__ptr), [old] "+a" (__old) : [new] "r" (__new) : "memory"); break; } default: __cmpxchg_wrong_size(); } if (__builtin_expect(!!(!success), 0)) *_old = __old; __builtin_expect(!!(success), 1); }); })) {
>
>
>
>
>
>
>   ({ int __ret_warn_on = !!(atomic_read(&head->refs) & 0x80000000); if (__builtin_expect(!!(__ret_warn_on), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/include/linux/freelist.h"), "i" (106), "i" ((1 << 0)|((1 << 1) | ((9) << 8))), "i" (sizeof(struct bug_entry))); } while (0); ({ asm volatile("378" ":\n\t" ".pushsection .discard.reachable\n\t" ".long " "378" "b - .\n\t" ".popsection\n\t"); }); do { } while(0); } while (0); __builtin_expect(!!(__ret_warn_on), 0); });
>
>
>
>
>
>   atomic_fetch_add(-2, &head->refs);
>
>   return head;
>  }
>
>
>
>
>
>  refs = atomic_fetch_add(-1, &prev->refs);
>  if (refs == 0x80000000 + 1)
>   __freelist_add(prev, list);
> }
>
> return ((void *)0);
>}
># 32 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kprobes.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kprobes.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/asm-generic/kprobes.h" 1
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kprobes.h" 2
>
>
>
>
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"
>struct paravirt_patch_site;
>
>void apply_paravirt(struct paravirt_patch_site *start,
>      struct paravirt_patch_site *end);
># 28 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"
>extern void text_poke_early(void *addr, const void *opcode, size_t len);
># 44 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"
>extern void *text_poke(void *addr, const void *opcode, size_t len);
>extern void text_poke_sync(void);
>extern void *text_poke_kgdb(void *addr, const void *opcode, size_t len);
>extern void *text_poke_copy(void *addr, const void *opcode, size_t len);
>extern void *text_poke_set(void *addr, int c, size_t len);
>extern int poke_int3_handler(struct pt_regs *regs);
>extern void text_poke_bp(void *addr, const void *opcode, size_t len, const void *emulate);
>
>extern void text_poke_queue(void *addr, const void *opcode, size_t len, const void *emulate);
>extern void text_poke_finish(void);
># 72 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) int text_opcode_size(u8 opcode)
>{
> int size = 0;
>
>
>
>
> switch(opcode) {
> case 0xCC: size = 1; break;
> case 0xC3: size = 1; break;
> case 0xE8: size = 5; break;
> case 0xE9: size = 5; break;
> case 0xEB: size = 2; break;
> }
>
>
>
> return size;
>}
>
>union text_poke_insn {
> u8 text[5];
> struct {
>  u8 opcode;
>  s32 disp;
> } __attribute__((packed));
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void __text_gen_insn(void *buf, u8 opcode, const void *addr, const void *dest, int size)
>{
> union text_poke_insn *insn = buf;
>
> do { if (__builtin_expect(!!(size < text_opcode_size(opcode)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"), "i" (105), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("379" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "379" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
>
> insn->opcode = opcode;
>
> if (size > 1) {
>  insn->disp = (long)dest - (long)(addr + size);
>  if (size == 2) {
>
>
>
>
>   do { if (__builtin_expect(!!((insn->disp >> 31) != (insn->disp >> 7)), 0)) do { do { } while(0); do { asm __inline volatile("1:\t" ".byte 0x0f, 0x0b" "\n" ".pushsection __bug_table,\"aw\"\n" "2:\t" ".long " "1b" " - 2b" "\t# bug_entry::bug_addr\n" "\t" ".long " "%c0" " - 2b" "\t# bug_entry::file\n" "\t.word %c1" "\t# bug_entry::line\n" "\t.word %c2" "\t# bug_entry::flags\n" "\t.org 2b+%c3\n" ".popsection" : : "i" ("/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"), "i" (116), "i" (0), "i" (sizeof(struct bug_entry))); } while (0); do { ({ asm volatile("380" ":\n\t" ".pushsection .discard.unreachable\n\t" ".long " "380" "b - .\n\t" ".popsection\n\t"); }); asm volatile(""); __builtin_unreachable(); } while (0); } while (0); } while (0);
>  }
> }
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void *text_gen_insn(u8 opcode, const void *addr, const void *dest)
>{
> static union text_poke_insn insn;
> __text_gen_insn(&insn, opcode, addr, dest, text_opcode_size(opcode));
> return &insn.text;
>}
>
>extern int after_bootmem;
>extern __attribute__((__section__(".data..ro_after_init"))) struct mm_struct *poking_mm;
>extern __attribute__((__section__(".data..ro_after_init"))) unsigned long poking_addr;
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void int3_emulate_jmp(struct pt_regs *regs, unsigned long ip)
>{
> regs->ip = ip;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void int3_emulate_push(struct pt_regs *regs, unsigned long val)
>{
># 152 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/text-patching.h"
> regs->sp -= sizeof(unsigned long);
> *(unsigned long *)regs->sp = val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>unsigned long int3_emulate_pop(struct pt_regs *regs)
>{
> unsigned long val = *(unsigned long *)regs->sp;
> regs->sp += sizeof(unsigned long);
> return val;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void int3_emulate_call(struct pt_regs *regs, unsigned long func)
>{
> int3_emulate_push(regs, regs->ip - 1 + 5);
> int3_emulate_jmp(regs, func);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>void int3_emulate_ret(struct pt_regs *regs)
>{
> unsigned long ip = int3_emulate_pop(regs);
> int3_emulate_jmp(regs, ip);
>}
># 19 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kprobes.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/insn.h" 1
># 12 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/insn.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/inat.h" 1
># 9 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/inat.h"
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/inat_types.h" 1
># 11 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/inat_types.h"
>typedef unsigned int insn_attr_t;
>typedef unsigned char insn_byte_t;
>typedef signed int insn_value_t;
># 10 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/inat.h" 2
># 97 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/inat.h"
>extern insn_attr_t inat_get_opcode_attribute(insn_byte_t opcode);
>extern int inat_get_last_prefix_id(insn_byte_t last_pfx);
>extern insn_attr_t inat_get_escape_attribute(insn_byte_t opcode,
>          int lpfx_id,
>          insn_attr_t esc_attr);
>extern insn_attr_t inat_get_group_attribute(insn_byte_t modrm,
>         int lpfx_id,
>         insn_attr_t esc_attr);
>extern insn_attr_t inat_get_avx_attribute(insn_byte_t opcode,
>       insn_byte_t vex_m,
>       insn_byte_t vex_pp);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_legacy_prefix(insn_attr_t attr)
>{
> attr &= (((1 << 4) - 1) << 0);
> return attr && attr <= 11;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_address_size_prefix(insn_attr_t attr)
>{
> return (attr & (((1 << 4) - 1) << 0)) == 11;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_operand_size_prefix(insn_attr_t attr)
>{
> return (attr & (((1 << 4) - 1) << 0)) == 1;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_rex_prefix(insn_attr_t attr)
>{
> return (attr & (((1 << 4) - 1) << 0)) == 12;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_last_prefix_id(insn_attr_t attr)
>{
> if ((attr & (((1 << 4) - 1) << 0)) > 3)
>  return 0;
> else
>  return attr & (((1 << 4) - 1) << 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_vex_prefix(insn_attr_t attr)
>{
> attr &= (((1 << 4) - 1) << 0);
> return attr == 13 || attr == 14 ||
>        attr == 15;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_evex_prefix(insn_attr_t attr)
>{
> return (attr & (((1 << 4) - 1) << 0)) == 15;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_vex3_prefix(insn_attr_t attr)
>{
> return (attr & (((1 << 4) - 1) << 0)) == 14;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_escape(insn_attr_t attr)
>{
> return attr & (((1 << 2) - 1) << (0 + 4));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_escape_id(insn_attr_t attr)
>{
> return (attr & (((1 << 2) - 1) << (0 + 4))) >> (0 + 4);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_group(insn_attr_t attr)
>{
> return attr & (((1 << 5) - 1) << ((0 + 4) + 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_group_id(insn_attr_t attr)
>{
> return (attr & (((1 << 5) - 1) << ((0 + 4) + 2))) >> ((0 + 4) + 2);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_group_common_attribute(insn_attr_t attr)
>{
> return attr & ~(((1 << 5) - 1) << ((0 + 4) + 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_has_immediate(insn_attr_t attr)
>{
> return attr & (((1 << 3) - 1) << (((0 + 4) + 2) + 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_immediate_size(insn_attr_t attr)
>{
> return (attr & (((1 << 3) - 1) << (((0 + 4) + 2) + 5))) >> (((0 + 4) + 2) + 5);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_has_modrm(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_is_force64(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3) + 1));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_has_second_immediate(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3) + 2));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_has_moffset(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3) + 3));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_has_variant(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3) + 4));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_accept_vex(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3) + 5));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_must_vex(insn_attr_t attr)
>{
> return attr & ((1 << (((((0 + 4) + 2) + 5) + 3) + 6)) | (1 << (((((0 + 4) + 2) + 5) + 3) + 7)));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int inat_must_evex(insn_attr_t attr)
>{
> return attr & (1 << (((((0 + 4) + 2) + 5) + 3) + 7));
>}
># 13 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/insn.h" 2
>
>
>
>struct insn_field {
> union {
>  insn_value_t value;
>  insn_byte_t bytes[4];
> };
>
> unsigned char got;
> unsigned char nbytes;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insn_field_set(struct insn_field *p, insn_value_t v,
>      unsigned char n)
>{
> p->value = v;
> p->nbytes = n;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insn_set_byte(struct insn_field *p, unsigned char n,
>     insn_byte_t v)
>{
> p->bytes[n] = v;
>}
># 68 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/insn.h"
>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;
> };
>
> int emulate_prefix_size;
> 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;
>};
># 134 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/insn.h"
>extern void insn_init(struct insn *insn, const void *kaddr, int buf_len, int x86_64);
>extern int insn_get_prefixes(struct insn *insn);
>extern int insn_get_opcode(struct insn *insn);
>extern int insn_get_modrm(struct insn *insn);
>extern int insn_get_sib(struct insn *insn);
>extern int insn_get_displacement(struct insn *insn);
>extern int insn_get_immediate(struct insn *insn);
>extern int insn_get_length(struct insn *insn);
>
>enum insn_mode {
> INSN_MODE_32,
> INSN_MODE_64,
>
> INSN_MODE_KERN,
> INSN_NUM_MODES,
>};
>
>extern int insn_decode(struct insn *insn, const void *kaddr, int buf_len, enum insn_mode m);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void insn_get_attribute(struct insn *insn)
>{
> insn_get_modrm(insn);
>}
>
>
>extern int insn_rip_relative(struct insn *insn);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_is_avx(struct insn *insn)
>{
> if (!insn->prefixes.got)
>  insn_get_prefixes(insn);
> return (insn->vex_prefix.value != 0);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_is_evex(struct insn *insn)
>{
> if (!insn->prefixes.got)
>  insn_get_prefixes(insn);
> return (insn->vex_prefix.nbytes == 4);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_has_emulate_prefix(struct insn *insn)
>{
> return !!insn->emulate_prefix_size;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) insn_byte_t insn_vex_m_bits(struct insn *insn)
>{
> if (insn->vex_prefix.nbytes == 2)
>  return 1;
> else if (insn->vex_prefix.nbytes == 3)
>  return ((insn->vex_prefix.bytes[1]) & 0x1f);
> else
>  return ((insn->vex_prefix.bytes[1]) & 0x03);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) insn_byte_t insn_vex_p_bits(struct insn *insn)
>{
> if (insn->vex_prefix.nbytes == 2)
>  return ((insn->vex_prefix.bytes[1]) & 0x03);
> else
>  return ((insn->vex_prefix.bytes[2]) & 0x03);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_last_prefix_id(struct insn *insn)
>{
> if (insn_is_avx(insn))
>  return insn_vex_p_bits(insn);
>
> if (insn->prefixes.bytes[3])
>  return inat_get_last_prefix_id(insn->prefixes.bytes[3]);
>
> return 0;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_rex_prefix(struct insn *insn)
>{
> return insn->prefixes.nbytes;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_vex_prefix(struct insn *insn)
>{
> return insn_offset_rex_prefix(insn) + insn->rex_prefix.nbytes;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_opcode(struct insn *insn)
>{
> return insn_offset_vex_prefix(insn) + insn->vex_prefix.nbytes;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_modrm(struct insn *insn)
>{
> return insn_offset_opcode(insn) + insn->opcode.nbytes;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_sib(struct insn *insn)
>{
> return insn_offset_modrm(insn) + insn->modrm.nbytes;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_displacement(struct insn *insn)
>{
> return insn_offset_sib(insn) + insn->sib.nbytes;
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_offset_immediate(struct insn *insn)
>{
> return insn_offset_displacement(insn) + insn->displacement.nbytes;
>}
># 269 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/insn.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int insn_masking_exception(struct insn *insn)
>{
> return insn->opcode.bytes[0] == 0x1f ||
>  (insn->opcode.bytes[0] == 0x8e &&
>   (((insn->modrm.bytes[0]) & 0x38) >> 3) == 2);
>}
># 20 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kprobes.h" 2
>
>
>
>struct pt_regs;
>struct kprobe;
>
>typedef u8 kprobe_opcode_t;
># 38 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kprobes.h"
>extern __attribute__((__externally_visible__)) kprobe_opcode_t optprobe_template_entry[];
>extern __attribute__((__externally_visible__)) kprobe_opcode_t optprobe_template_clac[];
>extern __attribute__((__externally_visible__)) kprobe_opcode_t optprobe_template_val[];
>extern __attribute__((__externally_visible__)) kprobe_opcode_t optprobe_template_call[];
>extern __attribute__((__externally_visible__)) kprobe_opcode_t optprobe_template_end[];
>
>
>
>
>
>
>extern const int kretprobe_blacklist_size;
>
>void arch_remove_kprobe(struct kprobe *p);
>
>extern void arch_kprobe_override_function(struct pt_regs *regs);
>
>
>struct arch_specific_insn {
>
> kprobe_opcode_t *insn;
>
>
>
>
>
>
>
> unsigned boostable:1;
> unsigned char size;
> union {
>  unsigned char opcode;
>  struct {
>   unsigned char type;
>  } jcc;
>  struct {
>   unsigned char type;
>   unsigned char asize;
>  } loop;
>  struct {
>   unsigned char reg;
>  } indirect;
> };
> s32 rel32;
> void (*emulate_op)(struct kprobe *p, struct pt_regs *regs);
>
> int tp_len;
>};
>
>struct arch_optimized_insn {
>
> kprobe_opcode_t copied_insn[4];
>
> kprobe_opcode_t *insn;
>
> size_t size;
>};
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int arch_prepared_optinsn(struct arch_optimized_insn *optinsn)
>{
> return optinsn->size;
>}
>
>struct prev_kprobe {
> struct kprobe *kp;
> unsigned long status;
> unsigned long old_flags;
> unsigned long saved_flags;
>};
>
>
>struct kprobe_ctlblk {
> unsigned long kprobe_status;
> unsigned long kprobe_old_flags;
> unsigned long kprobe_saved_flags;
> struct prev_kprobe prev_kprobe;
>};
>
>extern int kprobe_fault_handler(struct pt_regs *regs, int trapnr);
>extern int kprobe_exceptions_notify(struct notifier_block *self,
>        unsigned long val, void *data);
>extern int kprobe_int3_handler(struct pt_regs *regs);
># 33 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h" 2
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>struct kprobe;
>struct pt_regs;
>struct kretprobe;
>struct kretprobe_instance;
>typedef int (*kprobe_pre_handler_t) (struct kprobe *, struct pt_regs *);
>typedef void (*kprobe_post_handler_t) (struct kprobe *, struct pt_regs *,
>           unsigned long flags);
>typedef int (*kretprobe_handler_t) (struct kretprobe_instance *,
>        struct pt_regs *);
>
>struct kprobe {
> struct hlist_node hlist;
>
>
> struct list_head list;
>
>
> unsigned long nmissed;
>
>
> kprobe_opcode_t *addr;
>
>
> const char *symbol_name;
>
>
> unsigned int offset;
>
>
> kprobe_pre_handler_t pre_handler;
>
>
> kprobe_post_handler_t post_handler;
>
>
> kprobe_opcode_t opcode;
>
>
> struct arch_specific_insn ainsn;
>
>
>
>
>
> u32 flags;
>};
># 108 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kprobe_gone(struct kprobe *p)
>{
> return p->flags & 1;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kprobe_disabled(struct kprobe *p)
>{
> return p->flags & (2 | 1);
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kprobe_optimized(struct kprobe *p)
>{
> return p->flags & 4;
>}
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kprobe_ftrace(struct kprobe *p)
>{
> return p->flags & 8;
>}
># 141 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>struct kretprobe_holder {
> struct kretprobe *rp;
> refcount_t ref;
>};
>
>struct kretprobe {
> struct kprobe kp;
> kretprobe_handler_t handler;
> kretprobe_handler_t entry_handler;
> int maxactive;
> int nmissed;
> size_t data_size;
> struct freelist_head freelist;
> struct kretprobe_holder *rph;
>};
>
>
>
>struct kretprobe_instance {
> union {
>  struct freelist_node freelist;
>  struct callback_head rcu;
> };
> struct llist_node llist;
> struct kretprobe_holder *rph;
> kprobe_opcode_t *ret_addr;
> void *fp;
> char data[];
>};
>
>struct kretprobe_blackpoint {
> const char *name;
> void *addr;
>};
>
>struct kprobe_blacklist_entry {
> struct list_head list;
> unsigned long start_addr;
> unsigned long end_addr;
>};
>
>
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_current_kprobe; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct kprobe *) current_kprobe;
>extern __attribute__((__section__(".discard"))) __attribute__((unused)) char __pcpu_scope_kprobe_ctlblk; extern __attribute__((section(".data..percpu" ""))) __typeof__(struct kprobe_ctlblk) kprobe_ctlblk;
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kprobes_built_in(void)
>{
> return 1;
>}
>
>extern void kprobe_busy_begin(void);
>extern void kprobe_busy_end(void);
>
>
>extern void arch_prepare_kretprobe(struct kretprobe_instance *ri,
>       struct pt_regs *regs);
>extern int arch_trampoline_kprobe(struct kprobe *p);
>
>void arch_kretprobe_fixup_return(struct pt_regs *regs,
>     kprobe_opcode_t *correct_ret_addr);
>
>void __kretprobe_trampoline(void);
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) void *kretprobe_trampoline_addr(void)
>{
> return ((void *)(__kretprobe_trampoline));
>}
>
>
>unsigned long __kretprobe_trampoline_handler(struct pt_regs *regs,
>          void *frame_pointer);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__))
>unsigned long kretprobe_trampoline_handler(struct pt_regs *regs,
>        void *frame_pointer)
>{
> unsigned long ret;
>
>
>
>
>
> kprobe_busy_begin();
> ret = __kretprobe_trampoline_handler(regs, frame_pointer);
> kprobe_busy_end();
>
> return ret;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) struct kretprobe *get_kretprobe(struct kretprobe_instance *ri)
>{
> do { } while (0 && (!rcu_read_lock_any_held()))
>                                                                 ;
>
> return ({ do { extern void __compiletime_assert_381(void) __attribute__((__error__("Unsupported access size for {READ,WRITE}_ONCE()."))); if (!((sizeof(ri->rph->rp) == sizeof(char) || sizeof(ri->rph->rp) == sizeof(short) || sizeof(ri->rph->rp) == sizeof(int) || sizeof(ri->rph->rp) == sizeof(long)) || sizeof(ri->rph->rp) == sizeof(long long))) __compiletime_assert_381(); } while (0); (*(const volatile typeof( _Generic((ri->rph->rp), char: (char)0, unsigned char: (unsigned char)0, signed char: (signed char)0, unsigned short: (unsigned short)0, signed short: (signed short)0, unsigned int: (unsigned int)0, signed int: (signed int)0, unsigned long: (unsigned long)0, signed long: (signed long)0, unsigned long long: (unsigned long long)0, signed long long: (signed long long)0, default: (ri->rph->rp))) *)&(ri->rph->rp)); });
>}
># 255 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>extern struct kretprobe_blackpoint kretprobe_blacklist[];
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int init_test_probes(void)
>{
> return 0;
>}
>
>
>extern int arch_prepare_kprobe(struct kprobe *p);
>extern void arch_arm_kprobe(struct kprobe *p);
>extern void arch_disarm_kprobe(struct kprobe *p);
>extern int arch_init_kprobes(void);
>extern void kprobes_inc_nmissed_count(struct kprobe *p);
>extern bool arch_within_kprobe_blacklist(unsigned long addr);
>extern int arch_populate_kprobe_blacklist(void);
>extern bool arch_kprobe_on_func_entry(unsigned long offset);
>extern int kprobe_on_func_entry(kprobe_opcode_t *addr, const char *sym, unsigned long offset);
>
>extern bool within_kprobe_blacklist(unsigned long addr);
>extern int kprobe_add_ksym_blacklist(unsigned long entry);
>extern int kprobe_add_area_blacklist(unsigned long start, unsigned long end);
>
>struct kprobe_insn_cache {
> struct mutex mutex;
> void *(*alloc)(void);
> void (*free)(void *);
> const char *sym;
> struct list_head pages;
> size_t insn_size;
> int nr_garbage;
>};
>
>
>extern kprobe_opcode_t *__get_insn_slot(struct kprobe_insn_cache *c);
>extern void __free_insn_slot(struct kprobe_insn_cache *c,
>        kprobe_opcode_t *slot, int dirty);
>
>extern bool __is_insn_slot_addr(struct kprobe_insn_cache *c,
>    unsigned long addr);
># 317 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>int kprobe_cache_get_kallsym(struct kprobe_insn_cache *c, unsigned int *symnum,
>        unsigned long *value, char *type, char *sym);
># 327 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>extern struct kprobe_insn_cache kprobe_insn_slots; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kprobe_opcode_t *get_insn_slot(void) { return __get_insn_slot(&kprobe_insn_slots); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void free_insn_slot(kprobe_opcode_t *slot, int dirty){ __free_insn_slot(&kprobe_insn_slots, slot, dirty); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_kprobe_insn_slot(unsigned long addr) { return __is_insn_slot_addr(&kprobe_insn_slots, addr); };
>
>
>
>
>
>struct optimized_kprobe {
> struct kprobe kp;
> struct list_head list;
> struct arch_optimized_insn optinsn;
>};
>
>
>extern int arch_prepared_optinsn(struct arch_optimized_insn *optinsn);
>extern int arch_check_optimized_kprobe(struct optimized_kprobe *op);
>extern int arch_prepare_optimized_kprobe(struct optimized_kprobe *op,
>      struct kprobe *orig);
>extern void arch_remove_optimized_kprobe(struct optimized_kprobe *op);
>extern void arch_optimize_kprobes(struct list_head *oplist);
>extern void arch_unoptimize_kprobes(struct list_head *oplist,
>        struct list_head *done_list);
>extern void arch_unoptimize_kprobe(struct optimized_kprobe *op);
>extern int arch_within_optimized_kprobe(struct optimized_kprobe *op,
>     kprobe_opcode_t *addr);
>
>extern void opt_pre_handler(struct kprobe *p, struct pt_regs *regs);
>
>extern struct kprobe_insn_cache kprobe_optinsn_slots; static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) kprobe_opcode_t *get_optinsn_slot(void) { return __get_insn_slot(&kprobe_optinsn_slots); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void free_optinsn_slot(kprobe_opcode_t *slot, int dirty){ __free_insn_slot(&kprobe_optinsn_slots, slot, dirty); } static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool is_kprobe_optinsn_slot(unsigned long addr) { return __is_insn_slot_addr(&kprobe_optinsn_slots, addr); };
>
>
>extern int sysctl_kprobes_optimization;
>extern int proc_kprobes_optimization_handler(struct ctl_table *table,
>          int write, void *buffer,
>          size_t *length, loff_t *ppos);
>
>extern void wait_for_kprobe_optimizer(void);
>
>
>
>
>extern void kprobe_ftrace_handler(unsigned long ip, unsigned long parent_ip,
>      struct ftrace_ops *ops, struct ftrace_regs *fregs);
>extern int arch_prepare_kprobe_ftrace(struct kprobe *p);
>
>
>int arch_check_ftrace_location(struct kprobe *p);
>
>
>struct kprobe *get_kprobe(void *addr);
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kprobe *kprobe_running(void)
>{
> return (({ __this_cpu_preempt_check("read"); ({ typeof(current_kprobe) pscr_ret__; do { const void *__vpp_verify = (typeof((&(current_kprobe)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(current_kprobe)) { case 1: pscr_ret__ = ({ u8 pfo_val__; asm ("mov" "b " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "q" (pfo_val__) : [var] "m" (current_kprobe)); (typeof(current_kprobe))(unsigned long) pfo_val__; }); break; case 2: pscr_ret__ = ({ u16 pfo_val__; asm ("mov" "w " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (current_kprobe)); (typeof(current_kprobe))(unsigned long) pfo_val__; }); break; case 4: pscr_ret__ = ({ u32 pfo_val__; asm ("mov" "l " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (current_kprobe)); (typeof(current_kprobe))(unsigned long) pfo_val__; }); break; case 8: pscr_ret__ = ({ u64 pfo_val__; asm ("mov" "q " "%%""gs"":" "%" "[var]" ", " "%[val]" : [val] "=" "r" (pfo_val__) : [var] "m" (current_kprobe)); (typeof(current_kprobe))(unsigned long) pfo_val__; }); break; default: __bad_size_call_parameter(); break; } pscr_ret__; }); }));
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void reset_current_kprobe(void)
>{
> ({ __this_cpu_preempt_check("write"); do { do { const void *__vpp_verify = (typeof((&(current_kprobe)) + 0))((void *)0); (void)__vpp_verify; } while (0); switch(sizeof(current_kprobe)) { case 1: do { u8 pto_val__ = ((u8)(((unsigned long) ((void *)0)) & 0xff)); if (0) { typeof((current_kprobe)) pto_tmp__; pto_tmp__ = (((void *)0)); (void)pto_tmp__; } asm ("mov" "b " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((current_kprobe)) : [val] "qi" (pto_val__)); } while (0);break; case 2: do { u16 pto_val__ = ((u16)(((unsigned long) ((void *)0)) & 0xffff)); if (0) { typeof((current_kprobe)) pto_tmp__; pto_tmp__ = (((void *)0)); (void)pto_tmp__; } asm ("mov" "w " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((current_kprobe)) : [val] "ri" (pto_val__)); } while (0);break; case 4: do { u32 pto_val__ = ((u32)(((unsigned long) ((void *)0)) & 0xffffffff)); if (0) { typeof((current_kprobe)) pto_tmp__; pto_tmp__ = (((void *)0)); (void)pto_tmp__; } asm ("mov" "l " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((current_kprobe)) : [val] "ri" (pto_val__)); } while (0);break; case 8: do { u64 pto_val__ = ((u64)(((void *)0))); if (0) { typeof((current_kprobe)) pto_tmp__; pto_tmp__ = (((void *)0)); (void)pto_tmp__; } asm ("mov" "q " "%[val]" ", " "%%""gs"":" "%" "[var]" : [var] "+m" ((current_kprobe)) : [val] "re" (pto_val__)); } while (0);break; default: __bad_size_call_parameter();break; } } while (0); });
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct kprobe_ctlblk *get_kprobe_ctlblk(void)
>{
> return ({ do { const void *__vpp_verify = (typeof((&kprobe_ctlblk) + 0))((void *)0); (void)__vpp_verify; } while (0); ({ unsigned long tcp_ptr__; asm volatile("add " "%%""gs"":" "%" "1" ", %0" : "=r" (tcp_ptr__) : "m" (this_cpu_off), "0" (&kprobe_ctlblk)); (typeof(*(&kprobe_ctlblk)) *)tcp_ptr__; }); });
>}
>
>kprobe_opcode_t *kprobe_lookup_name(const char *name, unsigned int offset);
>int register_kprobe(struct kprobe *p);
>void unregister_kprobe(struct kprobe *p);
>int register_kprobes(struct kprobe **kps, int num);
>void unregister_kprobes(struct kprobe **kps, int num);
>
>int register_kretprobe(struct kretprobe *rp);
>void unregister_kretprobe(struct kretprobe *rp);
>int register_kretprobes(struct kretprobe **rps, int num);
>void unregister_kretprobes(struct kretprobe **rps, int num);
>
>void kprobe_flush_task(struct task_struct *tk);
>
>void kprobe_free_init_mem(void);
>
>int disable_kprobe(struct kprobe *kp);
>int enable_kprobe(struct kprobe *kp);
>
>void dump_kprobe(struct kprobe *kp);
>
>void *alloc_insn_page(void);
>
>void *alloc_optinsn_page(void);
>void free_optinsn_page(void *page);
>
>int kprobe_get_kallsym(unsigned int symnum, unsigned long *value, char *type,
>         char *sym);
>
>int arch_kprobe_get_kallsym(unsigned int *symnum, unsigned long *value,
>       char *type, char *sym);
># 497 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int disable_kretprobe(struct kretprobe *rp)
>{
> return disable_kprobe(&rp->kp);
>}
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int enable_kretprobe(struct kretprobe *rp)
>{
> return enable_kprobe(&rp->kp);
>}
># 520 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool is_kretprobe_trampoline(unsigned long addr)
>{
> return (void *)addr == kretprobe_trampoline_addr();
>}
>
>unsigned long kretprobe_find_ret_addr(struct task_struct *tsk, void *fp,
>          struct llist_node **cur);
># 542 "/usr/src/linux-5.14.21-150500.53/include/linux/kprobes.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) __attribute__((__always_inline__)) bool kprobe_page_fault(struct pt_regs *regs,
>           unsigned int trap)
>{
> if (!kprobes_built_in())
>  return false;
> if (user_mode(regs))
>  return false;
>
>
>
>
> if ((preempt_count() == 0 && !({ unsigned long _flags; do { ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); _flags = arch_local_save_flags(); } while (0); ({ ({ unsigned long __dummy; typeof(_flags) __dummy2; (void)(&__dummy == &__dummy2); 1; }); arch_irqs_disabled_flags(_flags); }); })))
>  return false;
> if (!kprobe_running())
>  return false;
> return kprobe_fault_handler(regs, trap);
>}
># 20 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h" 2
>
># 1 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kgdb.h" 1
># 49 "/usr/src/linux-5.14.21-150500.53/arch/x86/include/asm/kgdb.h"
>enum regnames {
> GDB_AX,
> GDB_BX,
> GDB_CX,
> GDB_DX,
> GDB_SI,
> GDB_DI,
> GDB_BP,
> GDB_SP,
> GDB_R8,
> GDB_R9,
> GDB_R10,
> GDB_R11,
> GDB_R12,
> GDB_R13,
> GDB_R14,
> GDB_R15,
> GDB_PC,
> GDB_PS,
> GDB_CS,
> GDB_SS,
> GDB_DS,
> GDB_ES,
> GDB_FS,
> GDB_GS,
>};
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void arch_kgdb_breakpoint(void)
>{
> asm("   int $3");
>}
>
>
>
>
>extern int kgdb_ll_trap(int cmd, const char *str,
>   struct pt_regs *regs, long err, int trap, int sig);
># 22 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h" 2
>
>
>
>struct pt_regs;
># 36 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern int kgdb_skipexception(int exception, struct pt_regs *regs);
>
>struct tasklet_struct;
>struct task_struct;
>struct uart_port;
># 50 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>void kgdb_breakpoint(void);
>
>extern int kgdb_connected;
>extern int kgdb_io_module_registered;
>
>extern atomic_t kgdb_setting_breakpoint;
>extern atomic_t kgdb_cpu_doing_single_step;
>
>extern struct task_struct *kgdb_usethread;
>extern struct task_struct *kgdb_contthread;
>
>enum kgdb_bptype {
> BP_BREAKPOINT = 0,
> BP_HARDWARE_BREAKPOINT,
> BP_WRITE_WATCHPOINT,
> BP_READ_WATCHPOINT,
> BP_ACCESS_WATCHPOINT,
> BP_POKE_BREAKPOINT,
>};
>
>enum kgdb_bpstate {
> BP_UNDEFINED = 0,
> BP_REMOVED,
> BP_SET,
> BP_ACTIVE
>};
>
>struct kgdb_bkpt {
> unsigned long bpt_addr;
> unsigned char saved_instr[1];
> enum kgdb_bptype type;
> enum kgdb_bpstate state;
>};
>
>struct dbg_reg_def_t {
> char *name;
> int size;
> int offset;
>};
>
>
>
>
>extern struct dbg_reg_def_t dbg_reg_def[];
>extern char *dbg_get_reg(int regno, void *mem, struct pt_regs *regs);
>extern int dbg_set_reg(int regno, void *mem, struct pt_regs *regs);
># 113 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern int kgdb_arch_init(void);
>
>
>
>
>
>
>
>extern void kgdb_arch_exit(void);
># 131 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void pt_regs_to_gdb_regs(unsigned long *gdb_regs, struct pt_regs *regs);
># 145 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void
>sleeping_thread_to_gdb_regs(unsigned long *gdb_regs, struct task_struct *p);
># 156 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void gdb_regs_to_pt_regs(unsigned long *gdb_regs, struct pt_regs *regs);
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern int
>kgdb_arch_handle_exception(int vector, int signo, int err_code,
>      char *remcom_in_buffer,
>      char *remcom_out_buffer,
>      struct pt_regs *regs);
># 187 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void
>kgdb_arch_handle_qxfer_pkt(char *remcom_in_buffer,
>      char *remcom_out_buffer);
># 200 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void kgdb_call_nmi_hook(void *ignored);
># 213 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void kgdb_roundup_cpus(void);
># 223 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void kgdb_arch_set_pc(struct pt_regs *regs, unsigned long pc);
>
>
>
>extern int kgdb_validate_break_address(unsigned long addr);
>extern int kgdb_arch_set_breakpoint(struct kgdb_bkpt *bpt);
>extern int kgdb_arch_remove_breakpoint(struct kgdb_bkpt *bpt);
># 239 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>extern void kgdb_arch_late(void);
># 262 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>struct kgdb_arch {
> unsigned char gdb_bpt_instr[1];
> unsigned long flags;
>
> int (*set_breakpoint)(unsigned long, char *);
> int (*remove_breakpoint)(unsigned long, char *);
> int (*set_hw_breakpoint)(unsigned long, int, enum kgdb_bptype);
> int (*remove_hw_breakpoint)(unsigned long, int, enum kgdb_bptype);
> void (*disable_hw_break)(struct pt_regs *regs);
> void (*remove_all_hw_break)(void);
> void (*correct_hw_break)(void);
>
> void (*enable_nmi)(bool on);
>};
># 293 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>struct kgdb_io {
> const char *name;
> int (*read_char) (void);
> void (*write_char) (u8);
> void (*flush) (void);
> int (*init) (void);
> void (*deinit) (void);
> void (*pre_exception) (void);
> void (*post_exception) (void);
> struct console *cons;
>};
>
>extern const struct kgdb_arch arch_kgdb_ops;
>
>extern unsigned long kgdb_arch_pc(int exception, struct pt_regs *regs);
>
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kgdb_register_nmi_console(void) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int kgdb_unregister_nmi_console(void) { return 0; }
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kgdb_nmi_poll_knock(void) { return true; }
>
>
>extern int kgdb_register_io_module(struct kgdb_io *local_kgdb_io_ops);
>extern void kgdb_unregister_io_module(struct kgdb_io *local_kgdb_io_ops);
>extern struct kgdb_io *dbg_io_ops;
>
>extern int kgdb_hex2long(char **ptr, unsigned long *long_val);
>extern char *kgdb_mem2hex(char *mem, char *buf, int count);
>extern int kgdb_hex2mem(char *buf, char *mem, int count);
>
>extern int kgdb_isremovedbreak(unsigned long addr);
>extern int kgdb_has_hit_break(unsigned long addr);
>
>extern int
>kgdb_handle_exception(int ex_vector, int signo, int err_code,
>        struct pt_regs *regs);
>extern int kgdb_nmicallback(int cpu, void *regs);
>extern int kgdb_nmicallin(int cpu, int trapnr, void *regs, int err_code,
>     atomic_t *snd_rdy);
>extern void gdbstub_exit(int status);
># 346 "/usr/src/linux-5.14.21-150500.53/include/linux/kgdb.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool kgdb_within_blocklist(unsigned long addr)
>{
>
> return within_kprobe_blacklist(addr);
>
>
>
>}
>
>extern int kgdb_single_step;
>extern atomic_t kgdb_active;
>
>
>extern bool dbg_is_early;
>extern void __attribute__((__section__(".init.text"))) __attribute__((__cold__)) dbg_late_init(void);
>extern void kgdb_panic(const char *msg);
>extern void kgdb_free_init_mem(void);
># 7 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h" 2
># 1 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h" 1
># 157 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h"
>struct fb_fix_screeninfo {
> char id[16];
> unsigned long smem_start;
>
> __u32 smem_len;
> __u32 type;
> __u32 type_aux;
> __u32 visual;
> __u16 xpanstep;
> __u16 ypanstep;
> __u16 ywrapstep;
> __u32 line_length;
> unsigned long mmio_start;
>
> __u32 mmio_len;
> __u32 accel;
>
> __u16 capabilities;
> __u16 reserved[2];
>};
># 188 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h"
>struct fb_bitfield {
> __u32 offset;
> __u32 length;
> __u32 msb_right;
>
>};
># 242 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h"
>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_cmap {
> __u32 start;
> __u32 len;
> __u16 *red;
> __u16 *green;
> __u16 *blue;
> __u16 *transp;
>};
>
>struct fb_con2fbmap {
> __u32 console;
> __u32 framebuffer;
>};
># 303 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h"
>enum {
>
> FB_BLANK_UNBLANK = 0,
>
>
> FB_BLANK_NORMAL = 0 + 1,
>
>
> FB_BLANK_VSYNC_SUSPEND = 1 + 1,
>
>
> FB_BLANK_HSYNC_SUSPEND = 2 + 1,
>
>
> FB_BLANK_POWERDOWN = 3 + 1
>};
># 330 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h"
>struct fb_vblank {
> __u32 flags;
> __u32 count;
> __u32 vcount;
> __u32 hcount;
> __u32 reserved[4];
>};
>
>
>
>
>
>struct fb_copyarea {
> __u32 dx;
> __u32 dy;
> __u32 width;
> __u32 height;
> __u32 sx;
> __u32 sy;
>};
>
>struct fb_fillrect {
> __u32 dx;
> __u32 dy;
> __u32 width;
> __u32 height;
> __u32 color;
> __u32 rop;
>};
>
>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;
>};
># 384 "/usr/src/linux-5.14.21-150500.53/include/uapi/linux/fb.h"
>struct fbcurpos {
> __u16 x, y;
>};
>
>struct fb_cursor {
> __u16 set;
> __u16 enable;
> __u16 rop;
> const char *mask;
> struct fbcurpos hot;
> struct fb_image image;
>};
># 8 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h" 2
># 16 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
># 1 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h" 1
># 17 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h" 2
>
>
>
>struct vm_area_struct;
>struct fb_info;
>struct device;
>struct file;
>struct videomode;
>struct device_node;
># 53 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>struct fb_chroma {
> __u32 redx;
> __u32 greenx;
> __u32 bluex;
> __u32 whitex;
> __u32 redy;
> __u32 greeny;
> __u32 bluey;
> __u32 whitey;
>};
>
>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_cmap_user {
> __u32 start;
> __u32 len;
> __u16 *red;
> __u16 *green;
> __u16 *blue;
> __u16 *transp;
>};
>
>struct fb_image_user {
> __u32 dx;
> __u32 dy;
> __u32 width;
> __u32 height;
> __u32 fg_color;
> __u32 bg_color;
> __u8 depth;
> const char *data;
> struct fb_cmap_user cmap;
>};
>
>struct fb_cursor_user {
> __u16 set;
> __u16 enable;
> __u16 rop;
> const char *mask;
> struct fbcurpos hot;
> struct fb_image_user image;
>};
># 140 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>struct fb_event {
> struct fb_info *info;
> void *data;
>};
>
>struct fb_blit_caps {
> u32 x;
> u32 y;
> u32 len;
> u32 flags;
>};
>
>
>extern int fb_register_client(struct notifier_block *nb);
>extern int fb_unregister_client(struct notifier_block *nb);
>extern int fb_notifier_call_chain(unsigned long val, void *v);
># 186 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>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 *info, void *dst, void *src, unsigned int size);
> void (*readio) (struct fb_info *info, void *dst, void *src, unsigned int size);
>};
>
>
>struct fb_deferred_io_pageref {
> struct page *page;
> unsigned long offset;
>
> struct list_head list;
>};
>
>struct fb_deferred_io {
>
> unsigned long delay;
> bool sort_pagereflist;
>
> short open_count;
>
> struct mutex lock;
> struct list_head pagereflist;
>
> void (*first_io)(struct fb_info *info);
> void (*deferred_io)(struct fb_info *info, struct list_head *pagelist);
>};
># 240 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>struct fb_ops {
>
> struct module *owner;
> int (*fb_open)(struct fb_info *info, int user);
> int (*fb_release)(struct fb_info *info, int user);
>
>
>
>
> ssize_t (*fb_read)(struct fb_info *info, char *buf,
>      size_t count, loff_t *ppos);
> ssize_t (*fb_write)(struct fb_info *info, const char *buf,
>       size_t count, loff_t *ppos);
>
>
>
> int (*fb_check_var)(struct fb_var_screeninfo *var, struct fb_info *info);
>
>
> int (*fb_set_par)(struct fb_info *info);
>
>
> int (*fb_setcolreg)(unsigned regno, unsigned red, unsigned green,
>       unsigned blue, unsigned transp, struct fb_info *info);
>
>
> int (*fb_setcmap)(struct fb_cmap *cmap, struct fb_info *info);
>
>
> int (*fb_blank)(int blank, struct fb_info *info);
>
>
> int (*fb_pan_display)(struct fb_var_screeninfo *var, struct fb_info *info);
>
>
> void (*fb_fillrect) (struct fb_info *info, const struct fb_fillrect *rect);
>
> void (*fb_copyarea) (struct fb_info *info, const struct fb_copyarea *region);
>
> void (*fb_imageblit) (struct fb_info *info, const struct fb_image *image);
>
>
> int (*fb_cursor) (struct fb_info *info, struct fb_cursor *cursor);
>
>
> int (*fb_sync)(struct fb_info *info);
>
>
> int (*fb_ioctl)(struct fb_info *info, unsigned int cmd,
>   unsigned long arg);
>
>
> int (*fb_compat_ioctl)(struct fb_info *info, unsigned cmd,
>   unsigned long arg);
>
>
> int (*fb_mmap)(struct fb_info *info, struct vm_area_struct *vma);
>
>
> void (*fb_get_caps)(struct fb_info *info, struct fb_blit_caps *caps,
>       struct fb_var_screeninfo *var);
>
>
> void (*fb_destroy)(struct fb_info *info);
>
>
> int (*fb_debug_enter)(struct fb_info *info);
> int (*fb_debug_leave)(struct fb_info *info);
>};
># 318 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>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 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_tile_ops {
>
> void (*fb_settile)(struct fb_info *info, struct fb_tilemap *map);
>
>
>
>
> void (*fb_tilecopy)(struct fb_info *info, struct fb_tilearea *area);
>
> void (*fb_tilefill)(struct fb_info *info, struct fb_tilerect *rect);
>
> void (*fb_tileblit)(struct fb_info *info, struct fb_tileblit *blit);
>
> void (*fb_tilecursor)(struct fb_info *info,
>         struct fb_tilecursor *cursor);
>
> int (*fb_get_tilemax)(struct fb_info *info);
>};
># 449 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>struct fb_info {
> refcount_t count;
> int node;
> int flags;
>
>
>
>
> int fbcon_rotate_hint;
> struct mutex lock;
> struct mutex mm_lock;
> struct fb_var_screeninfo var;
> struct fb_fix_screeninfo fix;
> struct fb_monspecs monspecs;
> struct fb_pixmap pixmap;
> struct fb_pixmap sprite;
> struct fb_cmap cmap;
> struct list_head modelist;
> struct fb_videomode *mode;
>
>
>
>
>
> struct backlight_device *bl_dev;
>
>
> struct mutex bl_curve_mutex;
> u8 bl_curve[128];
>
>
> struct delayed_work deferred_work;
> unsigned long npagerefs;
> struct fb_deferred_io_pageref *pagerefs;
> struct fb_deferred_io *fbdefio;
>
>
> const struct fb_ops *fbops;
> struct device *device;
> struct device *dev;
> int class_flag;
>
> struct fb_tile_ops *tileops;
>
> union {
>  char *screen_base;
>  char *screen_buffer;
> };
> unsigned long screen_size;
> void *pseudo_palette;
>
>
> u32 state;
> void *fbcon_par;
>
> void *par;
>
>
>
> struct apertures_struct {
>  unsigned int count;
>  struct aperture {
>   resource_size_t base;
>   resource_size_t size;
>  } ranges[0];
> } *apertures;
>
> bool skip_vt_switch;
>};
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct apertures_struct *alloc_apertures(unsigned int max_num) {
> struct apertures_struct *a;
>
> a = kzalloc(size_add(sizeof(*(a)), size_mul(max_num, sizeof(*(a)->ranges) + ((int)(sizeof(struct { int:(-!!(__builtin_types_compatible_p(typeof(((a)->ranges)), typeof(&((a)->ranges)[0])))); }))))), ((( gfp_t)(0x400u|0x800u)) | (( gfp_t)0x40u) | (( gfp_t)0x80u)));
> if (!a)
>  return ((void *)0);
> a->count = max_num;
> return a;
>}
># 601 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>extern int fb_set_var(struct fb_info *info, struct fb_var_screeninfo *var);
>extern int fb_pan_display(struct fb_info *info, struct fb_var_screeninfo *var);
>extern int fb_blank(struct fb_info *info, int blank);
>extern void cfb_fillrect(struct fb_info *info, const struct fb_fillrect *rect);
>extern void cfb_copyarea(struct fb_info *info, const struct fb_copyarea *area);
>extern void cfb_imageblit(struct fb_info *info, const struct fb_image *image);
>
>
>
>extern void sys_fillrect(struct fb_info *info, const struct fb_fillrect *rect);
>extern void sys_copyarea(struct fb_info *info, const struct fb_copyarea *area);
>extern void sys_imageblit(struct fb_info *info, const struct fb_image *image);
>extern ssize_t fb_sys_read(struct fb_info *info, char *buf,
>      size_t count, loff_t *ppos);
>extern ssize_t fb_sys_write(struct fb_info *info, const char *buf,
>       size_t count, loff_t *ppos);
>
>
>extern int register_framebuffer(struct fb_info *fb_info);
>extern void unregister_framebuffer(struct fb_info *fb_info);
>extern int remove_conflicting_pci_framebuffers(struct pci_dev *pdev,
>            const char *name);
>extern int remove_conflicting_framebuffers(struct apertures_struct *a,
>        const char *name, bool primary);
>extern int fb_prepare_logo(struct fb_info *fb_info, int rotate);
>extern int fb_show_logo(struct fb_info *fb_info, int rotate);
>extern char* fb_get_buffer_offset(struct fb_info *info, struct fb_pixmap *buf, u32 size);
>extern void fb_pad_unaligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 idx,
>    u32 height, u32 shift_high, u32 shift_low, u32 mod);
>extern void fb_pad_aligned_buffer(u8 *dst, u32 d_pitch, u8 *src, u32 s_pitch, u32 height);
>extern void fb_set_suspend(struct fb_info *info, int state);
>extern int fb_get_color_depth(struct fb_var_screeninfo *var,
>         struct fb_fix_screeninfo *fix);
>extern int fb_get_options(const char *name, char **option);
>extern int fb_new_modelist(struct fb_info *info);
>
>extern struct fb_info *registered_fb[32];
>extern int num_registered_fb;
>extern bool fb_center_logo;
>extern int fb_logo_count;
>extern struct class *fb_class;
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void lock_fb_info(struct fb_info *info)
>{
> mutex_lock(&info->lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void unlock_fb_info(struct fb_info *info)
>{
> mutex_unlock(&info->lock);
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void __fb_pad_aligned_buffer(u8 *dst, u32 d_pitch,
>        u8 *src, u32 s_pitch, u32 height)
>{
> u32 i, j;
>
> d_pitch -= s_pitch;
>
> for (i = height; i--; ) {
>
>  for (j = 0; j < s_pitch; j++)
>   *dst++ = *src++;
>  dst += d_pitch;
> }
>}
>
>
>int fb_deferred_io_mmap(struct fb_info *info, struct vm_area_struct *vma);
>extern int fb_deferred_io_init(struct fb_info *info);
>extern void fb_deferred_io_open(struct fb_info *info,
>    struct inode *inode,
>    struct file *file);
>extern void fb_deferred_io_release(struct fb_info *info);
>extern void fb_deferred_io_cleanup(struct fb_info *info);
>extern int fb_deferred_io_fsync(struct file *file, loff_t start,
>    loff_t end, int datasync);
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool fb_be_math(struct fb_info *info)
>{
># 697 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
> return false;
>
>
>}
>
>
>extern struct fb_info *framebuffer_alloc(size_t size, struct device *dev);
>extern void framebuffer_release(struct fb_info *info);
>extern int fb_init_device(struct fb_info *fb_info);
>extern void fb_cleanup_device(struct fb_info *head);
>extern void fb_bl_default_curve(struct fb_info *fb_info, u8 off, u8 min, u8 max);
># 724 "/usr/src/linux-5.14.21-150500.53/include/linux/fb.h"
>extern int fbmon_dpms(const struct fb_info *fb_info);
>extern int fb_get_mode(int flags, u32 val, struct fb_var_screeninfo *var,
>         struct fb_info *info);
>extern int fb_validate_mode(const struct fb_var_screeninfo *var,
>       struct fb_info *info);
>extern int fb_parse_edid(unsigned char *edid, struct fb_var_screeninfo *var);
>extern const unsigned char *fb_firmware_edid(struct device *device);
>extern void fb_edid_to_monspecs(unsigned char *edid,
>    struct fb_monspecs *specs);
>extern void fb_destroy_modedb(struct fb_videomode *modedb);
>extern int fb_find_mode_cvt(struct fb_videomode *mode, int margins, int rb);
>extern unsigned char *fb_ddc_read(struct i2c_adapter *adapter);
>
>extern int of_get_fb_videomode(struct device_node *np,
>          struct fb_videomode *fb,
>          int index);
>extern int fb_videomode_from_videomode(const struct videomode *vm,
>           struct fb_videomode *fbmode);
>
>
>
>
>
>extern void fb_var_to_videomode(struct fb_videomode *mode,
>    const struct fb_var_screeninfo *var);
>extern void fb_videomode_to_var(struct fb_var_screeninfo *var,
>    const struct fb_videomode *mode);
>extern int fb_mode_is_equal(const struct fb_videomode *mode1,
>       const struct fb_videomode *mode2);
>extern int fb_add_videomode(const struct fb_videomode *mode,
>       struct list_head *head);
>extern void fb_delete_videomode(const struct fb_videomode *mode,
>    struct list_head *head);
>extern const struct fb_videomode *fb_match_mode(const struct fb_var_screeninfo *var,
>      struct list_head *head);
>extern const struct fb_videomode *fb_find_best_mode(const struct fb_var_screeninfo *var,
>          struct list_head *head);
>extern const struct fb_videomode *fb_find_nearest_mode(const struct fb_videomode *mode,
>             struct list_head *head);
>extern void fb_destroy_modelist(struct list_head *head);
>extern void fb_videomode_to_modelist(const struct fb_videomode *modedb, int num,
>         struct list_head *head);
>extern const struct fb_videomode *fb_find_best_display(const struct fb_monspecs *specs,
>             struct list_head *head);
>
>
>extern int fb_alloc_cmap(struct fb_cmap *cmap, int len, int transp);
>extern int fb_alloc_cmap_gfp(struct fb_cmap *cmap, int len, int transp, gfp_t flags);
>extern void fb_dealloc_cmap(struct fb_cmap *cmap);
>extern int fb_copy_cmap(const struct fb_cmap *from, struct fb_cmap *to);
>extern int fb_cmap_to_user(const struct fb_cmap *from, struct fb_cmap_user *to);
>extern int fb_set_cmap(struct fb_cmap *cmap, struct fb_info *fb_info);
>extern int fb_set_user_cmap(struct fb_cmap_user *cmap, struct fb_info *fb_info);
>extern const struct fb_cmap *fb_default_cmap(int len);
>extern void fb_invert_cmaps(void);
>
>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 dmt_videomode {
> u32 dmt_id;
> u32 std_2byte_code;
> u32 cvt_3byte_code;
> const struct fb_videomode *mode;
>};
>
>extern const char *fb_mode_option;
>extern const struct fb_videomode vesa_modes[];
>extern const struct dmt_videomode dmt_modes[];
>
>struct fb_modelist {
> struct list_head list;
> struct fb_videomode mode;
>};
>
>extern int fb_find_mode(struct fb_var_screeninfo *var,
>   struct fb_info *info, const char *mode_option,
>   const struct fb_videomode *db,
>   unsigned int dbsize,
>   const struct fb_videomode *default_mode,
>   unsigned int default_bpp);
># 14 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h" 2
># 23 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
>enum backlight_update_reason {
>
>
>
> BACKLIGHT_UPDATE_HOTKEY,
>
>
>
>
> BACKLIGHT_UPDATE_SYSFS,
>};
>
>
>
>
>
>
>enum backlight_type {
>
>
>
>
>
> BACKLIGHT_RAW = 1,
>
>
>
>
>
>
> BACKLIGHT_PLATFORM,
>
>
>
>
>
>
> BACKLIGHT_FIRMWARE,
>
>
>
>
> BACKLIGHT_TYPE_MAX,
>};
>
>
>
>
>
>
>
>enum backlight_notification {
>
>
>
> BACKLIGHT_REGISTERED,
>
>
>
>
> BACKLIGHT_UNREGISTERED,
>};
>
>
>
>
>
>enum backlight_scale {
>
>
>
> BACKLIGHT_SCALE_UNKNOWN = 0,
>
>
>
>
>
>
> BACKLIGHT_SCALE_LINEAR,
>
>
>
>
>
>
>
> BACKLIGHT_SCALE_NON_LINEAR,
>};
>
>struct backlight_device;
>struct fb_info;
>
>
>
>
>
>
>struct backlight_ops {
>
>
>
>
>
>
>
> unsigned int options;
># 146 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int (*update_status)(struct backlight_device *);
># 160 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int (*get_brightness)(struct backlight_device *);
># 174 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int (*check_fb)(struct backlight_device *bd, struct fb_info *info);
>};
>
>
>
>
>
>
>struct backlight_properties {
># 194 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int brightness;
># 203 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int max_brightness;
># 219 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int power;
># 238 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> int fb_blank;
># 249 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> enum backlight_type type;
># 264 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> unsigned int state;
>
>
>
>
>
>
>
> enum backlight_scale scale;
>};
>
>
>
>
>
>
>struct backlight_device {
>
>
>
> struct backlight_properties props;
># 294 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> struct mutex update_lock;
># 303 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> struct mutex ops_lock;
># 312 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
> const struct backlight_ops *ops;
>
>
>
>
> struct notifier_block fb_notif;
>
>
>
>
> struct list_head entry;
>
>
>
>
> struct device dev;
>
>
>
>
>
>
>
> bool fb_bl_on[32];
>
>
>
>
> int use_count;
>};
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int backlight_update_status(struct backlight_device *bd)
>{
> int ret = -2;
>
> mutex_lock(&bd->update_lock);
> if (bd->ops && bd->ops->update_status)
>  ret = bd->ops->update_status(bd);
> mutex_unlock(&bd->update_lock);
>
> return ret;
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int backlight_enable(struct backlight_device *bd)
>{
> if (!bd)
>  return 0;
>
> bd->props.power = FB_BLANK_UNBLANK;
> bd->props.fb_blank = FB_BLANK_UNBLANK;
> bd->props.state &= ~(1 << 1);
>
> return backlight_update_status(bd);
>}
>
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int backlight_disable(struct backlight_device *bd)
>{
> if (!bd)
>  return 0;
>
> bd->props.power = FB_BLANK_POWERDOWN;
> bd->props.fb_blank = FB_BLANK_POWERDOWN;
> bd->props.state |= (1 << 1);
>
> return backlight_update_status(bd);
>}
># 403 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) bool backlight_is_blank(const struct backlight_device *bd)
>{
> return bd->props.power != FB_BLANK_UNBLANK ||
>        bd->props.fb_blank != FB_BLANK_UNBLANK ||
>        bd->props.state & ((1 << 0) | (1 << 1));
>}
># 421 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) int backlight_get_brightness(const struct backlight_device *bd)
>{
> if (backlight_is_blank(bd))
>  return 0;
> else
>  return bd->props.brightness;
>}
>
>struct backlight_device *
>backlight_device_register(const char *name, struct device *dev, void *devdata,
>     const struct backlight_ops *ops,
>     const struct backlight_properties *props);
>struct backlight_device *
>devm_backlight_device_register(struct device *dev, const char *name,
>          struct device *parent, void *devdata,
>          const struct backlight_ops *ops,
>          const struct backlight_properties *props);
>void backlight_device_unregister(struct backlight_device *bd);
>void devm_backlight_device_unregister(struct device *dev,
>          struct backlight_device *bd);
>void backlight_force_update(struct backlight_device *bd,
>       enum backlight_update_reason reason);
>int backlight_register_notifier(struct notifier_block *nb);
>int backlight_unregister_notifier(struct notifier_block *nb);
>struct backlight_device *backlight_device_get_by_name(const char *name);
>struct backlight_device *backlight_device_get_by_type(enum backlight_type type);
>int backlight_device_set_brightness(struct backlight_device *bd,
>        unsigned long brightness);
># 464 "/usr/src/linux-5.14.21-150500.53/include/linux/backlight.h"
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void * bl_get_data(struct backlight_device *bl_dev)
>{
> return dev_get_drvdata(&bl_dev->dev);
>}
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) struct backlight_device *
>of_find_backlight_by_node(struct device_node *node)
>{
> return ((void *)0);
>}
>
>
>
>struct backlight_device *devm_of_find_backlight(struct device *dev);
># 1993 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-linux.h" 2
>
>
>
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vm_flags_set(struct vm_area_struct *vma, vm_flags_t flags)
>{
>    vma->vm_flags |= flags;
>}
>
>static inline __attribute__((__gnu_inline__)) __attribute__((__unused__)) __attribute__((no_instrument_function)) void vm_flags_clear(struct vm_area_struct *vma, vm_flags_t flags)
>{
>    vma->vm_flags &= ~flags;
>}
># 16 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
>
>
>
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nv_compiler.h" 1
># 20 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-reg.h" 1
># 753 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-reg.h"
>extern nv_parm_t nv_parms[];
># 21 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/conftest/patches.h" 1
>static struct {
>                const char *short_description;
>                const char *description;
>              } __nv_patches[] = {
>{ ((void *)0), ((void *)0) } };
># 22 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/rmil.h" 1
># 15 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/rmil.h"
>int rm_gvi_isr (nvidia_stack_t *, nv_state_t *, NvU32 *);
>void rm_gvi_bh (nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_gvi_attach_device (nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_gvi_detach_device (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_gvi_init_private_state (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_init_gvi_device (nvidia_stack_t *, nv_state_t *);
>NvU32 rm_shutdown_gvi_device (nvidia_stack_t *, nv_state_t *);
>NvU32 rm_gvi_suspend (nvidia_stack_t *, nv_state_t *);
>NvU32 rm_gvi_resume (nvidia_stack_t *, nv_state_t *);
>NvS32 rm_gvi_free_private_state (nvidia_stack_t *, nv_state_t *);
>NV_STATUS rm_gvi_get_device_name (nvidia_stack_t *, nv_state_t *, NvU32, NvU32, NvU8 *);
>NV_STATUS rm_gvi_get_firmware_version (nvidia_stack_t *, nv_state_t *, NvU32 *, NvU32 *, NvU32 *);
># 23 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-instance.h" 1
># 12 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-instance.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-frontend.h" 1
># 18 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-frontend.h"
># 1 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-register-module.h" 1
># 21 "/usr/src/kernel-modules/nvidia-390.157-default/common/inc/nv-register-module.h"
>typedef struct nvidia_module_s {
>    struct module *owner;
>
>
>    const char *module_name;
>
>
>    NvU32 instance;
>
>
>    int (*open)(struct inode *, struct file *filp);
>    int (*close)(struct inode *, struct file *filp);
>    int (*mmap)(struct file *filp, struct vm_area_struct *vma);
>    int (*ioctl)(struct inode *, struct file * file, unsigned int cmd, unsigned long arg);
>    unsigned int (*poll)(struct file * file, poll_table *wait);
>
>} nvidia_module_t;
>
>int nvidia_register_module(nvidia_module_t *);
>int nvidia_unregister_module(nvidia_module_t *);
># 19 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-frontend.h" 2
># 31 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-frontend.h"
>int nvidia_frontend_add_device(nvidia_module_t *, nv_linux_state_t *);
>int nvidia_frontend_remove_device(nvidia_module_t *, nv_linux_state_t *);
># 13 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-instance.h" 2
>
>extern const int nv_multiple_kernel_modules;
>extern unsigned const int nv_module_instance;
>extern const char *nv_device_name;
>extern const char *nvidia_stack_cache_name;
>extern const char *nvidia_pte_cache_name;
>extern const char *nvidia_p2p_page_cache_name;
>extern struct pci_driver nv_pci_driver;
>extern nvidia_module_t nv_fops;
>
>int nv_pci_register_driver(struct pci_driver *);
># 24 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c" 2
>
>static const char *__README_warning =
>    "The NVIDIA graphics driver tries to detect potential problems\n"
>    "with the host system and warns about them using the system's\n"
>    "logging mechanisms. Important warning message are also logged\n"
>    "to dedicated text files in this directory.\n";
>
>static const char *__README_patches =
>    "The NVIDIA graphics driver's kernel interface files can be\n"
>    "patched to improve compatibility with new Linux kernels or to\n"
>    "fix bugs in these files. When applied, each official patch\n"
>    "provides a short text file with a short description of itself\n"
>    "in this directory.\n";
>
>static struct proc_dir_entry *proc_nvidia;
>static struct proc_dir_entry *proc_nvidia_warnings;
>static struct proc_dir_entry *proc_nvidia_patches;
>static struct proc_dir_entry *proc_nvidia_gpus;
>
>extern char *NVreg_RegistryDwords;
>extern char *NVreg_RegistryDwordsPerDevice;
>extern char *NVreg_RmMsg;
>extern char *NVreg_AssignGpus;
>
>static char nv_registry_keys[512];
>
>static int nv_procfs_read_registry(struct seq_file *s, void *v);
>
>
>
>static int
>nv_procfs_read_gpu_info(
>    struct seq_file *s,
>    void *v
>)
>{
>    nv_state_t *nv = s->private;
>    nv_linux_state_t *nvl = ((nv_linux_state_t *)nv->os_state);
>    struct pci_dev *dev = nvl->dev;
>    char *type, *fmt, tmpstr[40];
>    int status;
>    NvU8 *uuid;
>    NvU32 vbios_rev1, vbios_rev2, vbios_rev3, vbios_rev4, vbios_rev5;
>    NvU32 fpga_rev1, fpga_rev2, fpga_rev3;
>    nvidia_stack_t *sp = ((void *)0);
>
>    if (nv_kmem_cache_alloc_stack(&sp) != 0)
>    {
>        return 0;
>    }
>
>    if (((nv)->flags & 0x0200))
>    {
>        if (rm_gvi_get_device_name(sp, nv, dev->device, 40,
>                                   tmpstr) != NV_OK)
>        {
>            strcpy (tmpstr, "Unknown");
>        }
>    }
>    else
>    {
>        if (rm_get_device_name(sp, nv, dev->device, dev->subsystem_vendor,
>                    dev->subsystem_device, 40,
>                    tmpstr) != NV_OK)
>        {
>            strcpy (tmpstr, "Unknown");
>        }
>    }
>
>    seq_printf(s, "Model: \t\t %s\n", tmpstr);
>    seq_printf(s, "IRQ:   \t\t %d\n", nv->interrupt_line);
>
>    if (((nv)->flags & 0x0200))
>    {
>        status = rm_gvi_get_firmware_version(sp, nv, &fpga_rev1, &fpga_rev2,
>                                             &fpga_rev3);
>        if (status != NV_OK)
>            seq_printf(s, "Firmware: \t ????.??.??\n");
>        else
>        {
>            fmt = "Firmware: \t %x.%x.%x\n";
>            seq_printf(s, fmt, fpga_rev1, fpga_rev2, fpga_rev3);
>        }
>    }
>    else
>    {
>        if (rm_get_gpu_uuid(sp, nv, &uuid, ((void *)0)) == NV_OK)
>        {
>            seq_printf(s, "GPU UUID: \t %s\n", (char *)uuid);
>            os_free_mem(uuid);
>        }
>
>        if (rm_get_vbios_version(sp, nv, &vbios_rev1, &vbios_rev2,
>                    &vbios_rev3, &vbios_rev4,
>                    &vbios_rev5) != NV_OK)
>        {
>            seq_printf(s, "Video BIOS: \t ??.??.??.??.??\n");
>        }
>        else
>        {
>            fmt = "Video BIOS: \t %02x.%02x.%02x.%02x.%02x\n";
>            seq_printf(s, fmt, vbios_rev1, vbios_rev2, vbios_rev3, vbios_rev4,
>                       vbios_rev5);
>        }
>    }
>
>    if (nv_find_pci_capability(dev, 0x10))
>        type = "PCIe";
>    else
>        type = "PCI";
>    seq_printf(s, "Bus Type: \t %s\n", type);
>
>    seq_printf(s, "DMA Size: \t %d bits\n",
>     nv_count_bits(dev->dma_mask));
>    seq_printf(s, "DMA Mask: \t 0x%llx\n", dev->dma_mask);
>    seq_printf(s, "Bus Location: \t %04x:%02x:%02x.%x\n",
>                   nv->pci_info.domain, nv->pci_info.bus,
>                   nv->pci_info.slot, ((dev->devfn) & 0x07));
>    seq_printf(s, "Device Minor: \t %u\n", nvl->minor_num);
># 156 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c"
>    nv_kmem_cache_free_stack(sp);
>
>    return 0;
>}
>
>static int nv_procfs_open_gpu_info( struct inode *inode, struct file *filep ) { return single_open(filep, nv_procfs_read_gpu_info, PDE_DATA(inode)); } static const nv_proc_ops_t nv_procfs_gpu_info_fops = { .proc_open = nv_procfs_open_gpu_info, .proc_read = seq_read, .proc_lseek = seq_lseek, .proc_release = single_release, };;
>
>static int
>nv_procfs_read_version(
>    struct seq_file *s,
>    void *v
>)
>{
>    seq_printf(s, "NVRM version: %s\n", pNVRM_ID);
>    seq_printf(s, "GCC version:  %s\n", "gcc version 7.5.0 (SUSE Linux) ");
>
>    return 0;
>}
>
>static int nv_procfs_open_version( struct inode *inode, struct file *filep ) { return single_open(filep, nv_procfs_read_version, PDE_DATA(inode)); } static const nv_proc_ops_t nv_procfs_version_fops = { .proc_open = nv_procfs_open_version, .proc_read = seq_read, .proc_lseek = seq_lseek, .proc_release = single_release, };;
>
>static int
>nv_procfs_open_file(
>    struct inode *inode,
>    struct file *file,
>    nv_file_private_t **nvfpp
>)
>{
>    nv_file_private_t *nvfp = ((void *)0);
>    nvidia_stack_t *sp = ((void *)0);
>    int status;
>
>    nvfp = nv_alloc_file_private();
>    if (nvfp == ((void *)0))
>    {
>        nv_printf(0x4, "NVRM: failed to allocate file private!\n");
>        return -12;
>    }
>
>    nvfp->proc_data = PDE_DATA(inode);
>
>    if (0 == (file->f_mode & (( fmode_t)0x2)))
>        goto done;
>
>    status = nv_kmem_cache_alloc_stack(&sp);
>    if (status != 0)
>    {
>        nv_free_file_private(nvfp);
>        return status;
>    }
>
>    if (NV_OK != os_alloc_mem((void **)&nvfp->data, (64 * ((1UL) << 12))))
>    {
>        nv_free_file_private(nvfp);
>        nv_kmem_cache_free_stack(sp);
>        return -12;
>    }
>
>    os_mem_set((void *)nvfp->data, 0, (64 * ((1UL) << 12)));
>    nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS] = sp;
>
>done:
>    *nvfpp = nvfp;
>    return 0;
>}
>
>static int
>nv_procfs_open_registry(
>    struct inode *inode,
>    struct file *file
>)
>{
>    nv_file_private_t *nvfp = ((void *)0);
>    int retval;
>
>    retval = nv_procfs_open_file(inode, file, &nvfp);
>    if (retval == 0)
>    {
>        single_open(file, nv_procfs_read_registry, nvfp);
>    }
>
>    return retval;
>}
>
>static int
>nv_procfs_close_registry(
>    struct inode *inode,
>    struct file *file
>)
>{
>    struct seq_file *s = file->private_data;
>    nv_file_private_t *nvfp;
>    nv_state_t *nv;
>    nv_linux_state_t *nvl = ((void *)0);
>    nvidia_stack_t *sp = ((void *)0);
>    char *key_name, *key_value, *registry_keys;
>    size_t key_len, len;
>    long count;
>    NV_STATUS rm_status;
>    int rc = 0;
>
>    nvfp = s->private;
>    single_release(inode, file);
>
>    sp = nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS];
>
>    if (0 != nvfp->off)
>    {
>        nv = nvfp->proc_data;
>        if (nv != ((void *)0))
>            nvl = ((nv_linux_state_t *)nv->os_state);
>        key_value = (char *)nvfp->data;
>
>        key_name = strsep(&key_value, "=");
>
>        if (((void *)0) == key_name || ((void *)0) == key_value)
>        {
>            rc = -22;
>            goto done;
>        }
>
>        key_len = (strlen(key_name) + 1);
>        count = (nvfp->off - key_len);
>
>        if (count <= 0)
>        {
>            rc = -22;
>            goto done;
>        }
>
>        rm_status = rm_write_registry_binary(sp, nv, "NVreg", key_name,
>                key_value, count);
>        if (rm_status != NV_OK)
>        {
>            rc = -14;
>            goto done;
>        }
>
>        registry_keys = ((nvl != ((void *)0)) ?
>                nvl->registry_keys : nv_registry_keys);
>        if (strstr(registry_keys, key_name) != ((void *)0))
>            goto done;
>        len = strlen(registry_keys);
>
>        if ((len + key_len + 2) <= 512)
>        {
>            if (len != 0)
>                strcat(registry_keys, ", ");
>            strcat(registry_keys, key_name);
>        }
>    }
>
>done:
>    if (((void *)0) != nvfp->data)
>        os_free_mem(nvfp->data);
>
>    if (sp != ((void *)0))
>    {
>        nv_kmem_cache_free_stack(sp);
>        nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS] = ((void *)0);
>    }
>
>    nv_free_file_private(nvfp);
>
>    return rc;
>}
>
>static int
>nv_procfs_read_params(
>    struct seq_file *s,
>    void *v
>)
>{
>    unsigned int i;
>    nv_parm_t *entry;
>
>    for (i = 0; (entry = &nv_parms[i])->name != ((void *)0); i++)
>        seq_printf(s, "%s: %u\n", entry->name, *entry->data);
>
>    seq_printf(s, "RegistryDwords: \"%s\"\n",
>               (NVreg_RegistryDwords != ((void *)0)) ? NVreg_RegistryDwords : "");
>    seq_printf(s, "RegistryDwordsPerDevice: \"%s\"\n",
>               (NVreg_RegistryDwordsPerDevice != ((void *)0)) ? NVreg_RegistryDwordsPerDevice : "");
>    seq_printf(s, "RmMsg: \"%s\"\n",
>               (NVreg_RmMsg != ((void *)0)) ? NVreg_RmMsg : "");
>    seq_printf(s, "AssignGpus: \"%s\"\n",
>               (NVreg_AssignGpus != ((void *)0)) ? NVreg_AssignGpus : "");
>    return 0;
>}
>
>static int nv_procfs_open_params( struct inode *inode, struct file *filep ) { return single_open(filep, nv_procfs_read_params, PDE_DATA(inode)); } static const nv_proc_ops_t nv_procfs_params_fops = { .proc_open = nv_procfs_open_params, .proc_read = seq_read, .proc_lseek = seq_lseek, .proc_release = single_release, };;
>
>static int
>nv_procfs_read_registry(
>    struct seq_file *s,
>    void *v
>)
>{
>    nv_file_private_t *nvfp = s->private;
>    nv_state_t *nv = nvfp->proc_data;
>    nv_linux_state_t *nvl = ((void *)0);
>    char *registry_keys;
>
>    if (nv != ((void *)0))
>        nvl = ((nv_linux_state_t *)nv->os_state);
>    registry_keys = ((nvl != ((void *)0)) ?
>            nvl->registry_keys : nv_registry_keys);
>
>    seq_printf(s, "Binary: \"%s\"\n", registry_keys);
>    return 0;
>}
>
>static ssize_t
>nv_procfs_write_file(
>    struct file *file,
>    const char *buffer,
>    size_t count,
>    loff_t *pos
>)
>{
>    int status = 0;
>    struct seq_file *s = file->private_data;
>    nv_file_private_t *nvfp = s->private;
>    char *proc_buffer;
>    unsigned long bytes_left;
>
>    down(&nvfp->fops_sp_lock[NV_FOPS_STACK_INDEX_PROCFS]);
>
>    bytes_left = ((64 * ((1UL) << 12)) - nvfp->off - 1);
>
>    if (count == 0)
>    {
>        status = -22;
>        goto done;
>    }
>    else if ((bytes_left == 0) || (count > bytes_left))
>    {
>        status = -28;
>        goto done;
>    }
>
>    proc_buffer = &((char *)nvfp->data)[nvfp->off];
>
>    if (copy_from_user(proc_buffer, buffer, count))
>    {
>        nv_printf(0x4, "NVRM: failed to copy in proc data!\n");
>        status = -14;
>    }
>    else
>    {
>        nvfp->off += count;
>    }
>
>    *pos = nvfp->off;
>
>done:
>    up(&nvfp->fops_sp_lock[NV_FOPS_STACK_INDEX_PROCFS]);
>
>    return ((status < 0) ? status : (int)count);
>}
>
>static nv_proc_ops_t nv_procfs_registry_fops = {
>    
>    .proc_open = nv_procfs_open_registry,
>    .proc_read = seq_read,
>    .proc_write = nv_procfs_write_file,
>    .proc_lseek = seq_lseek,
>    .proc_release = nv_procfs_close_registry,
>};
>
>
>
>
>void
>exercise_error_forwarding_va(
>    nv_state_t *nv,
>    NvU32 err,
>    const char *fmt,
>    ...
>)
>{
>    va_list arguments;
>
>    __builtin_va_start(arguments, fmt);
>    nv_log_error(nv, err, fmt, arguments);
>    __builtin_va_end(arguments);
>}
>
>static int
>nv_procfs_show_exercise_error_forwarding(
>    struct seq_file *m,
>    void *v
>)
>{
>    return 0;
>}
>
>static int
>nv_procfs_open_exercise_error_forwarding(
>    struct inode *inode,
>    struct file *file
>)
>{
>    nv_file_private_t *nvfp = ((void *)0);
>    int retval;
>
>    retval = nv_procfs_open_file(inode, file, &nvfp);
>
>    if (retval == 0)
>        single_open(file, nv_procfs_show_exercise_error_forwarding, nvfp);
>
>    return retval;
>}
>
>static int
>nv_procfs_close_exercise_error_forwarding(
>    struct inode *inode,
>    struct file *file
>)
>{
>    struct seq_file *s = file->private_data;
>    nv_file_private_t *nvfp = s->private;
>    nvidia_stack_t *sp = nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS];
>    nv_state_t *nv = nvfp->proc_data;
>    char *proc_buffer = &((char *)nvfp->data)[0];
>    size_t count = nvfp->off;
>    int i = 0, status = 0;
>    NvU32 xid = 0;
>    const NvU8 MAX_XID_DIGITS = 3;
>
>    single_release(inode, file);
>
>    while (i < count && i <= MAX_XID_DIGITS && proc_buffer[i] != ',')
>    {
>        if (proc_buffer[i] < '0' || proc_buffer[i] > '9')
>        {
>            status = -22;
>            goto done;
>        }
>
>        xid = xid * 10 + (proc_buffer[i++] - '0');
>    }
>
>    if (count > (i + 1) && proc_buffer[i] == ',')
>        exercise_error_forwarding_va(nv, xid, &proc_buffer[i + 1], 0xdeadbee0,
>                0xdeadbee1, 0xdeadbee2, 0xdeadbee3, 0xdeadbee4, 0xdeadbee5);
>    else
>        status = -22;
>
>done:
>    if (((void *)0) != nvfp->data)
>        os_free_mem(nvfp->data);
>
>    if (sp != ((void *)0))
>    {
>        nv_kmem_cache_free_stack(sp);
>        nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS] = ((void *)0);
>    }
>
>    nv_free_file_private(nvfp);
>
>    return status;
>}
>
>static nv_proc_ops_t nv_procfs_exercise_error_forwarding_fops = {
>    
>    .proc_open = nv_procfs_open_exercise_error_forwarding,
>    .proc_write = nv_procfs_write_file,
>    .proc_release = nv_procfs_close_exercise_error_forwarding,
>};
>
>static int
>nv_procfs_read_unbind_lock(
>    struct seq_file *s,
>    void *v
>)
>{
>    nv_file_private_t *nvfp = s->private;
>    nv_state_t *nv = nvfp->proc_data;
>    nv_linux_state_t *nvl = ((nv_linux_state_t *)nv->os_state);
>
>    down(&nvl->ldata_lock);
>    if (nv->flags & 0x4000)
>    {
>        seq_printf(s, "1\n");
>    }
>    else
>    {
>        seq_printf(s, "0\n");
>    }
>    up(&nvl->ldata_lock);
>
>    return 0;
>}
>
>static int
>nv_procfs_open_unbind_lock(
>    struct inode *inode,
>    struct file *file
>)
>{
>    nv_file_private_t *nvfp = ((void *)0);
>    int retval;
>
>    retval = nv_procfs_open_file(inode, file, &nvfp);
>    if (retval == 0)
>    {
>        single_open(file, nv_procfs_read_unbind_lock, nvfp);
>    }
>
>    return retval;
>}
>
>static int
>nv_procfs_close_unbind_lock(
>    struct inode *inode,
>    struct file *file
>)
>{
>    struct seq_file *s = file->private_data;
>    nv_file_private_t *nvfp;
>    nv_state_t *nv;
>    nvidia_stack_t *sp = ((void *)0);
>    int rc = 0;
>    nv_linux_state_t * nvl;
>    int value;
>
>    nvfp = s->private;
>    single_release(inode, file);
>
>    sp = nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS];
>
>    if (0 != nvfp->off)
>    {
>        nv = nvfp->proc_data;
>        nvl = ((nv_linux_state_t *)nv->os_state);
>
>        if (((void *)0) == nvfp->data || ((void *)0) == nv)
>        {
>            rc = -22;
>            goto done;
>        }
>
>        if (sscanf((char *)nvfp->data, "%u\n", &value) != 1)
>        {
>            rc = -22;
>            goto done;
>        }
>
>        down(&nvl->ldata_lock);
>        if ((value == 1) && !(nv->flags & 0x4000))
>        {
>            if (atomic_read(&(nvl->usage_count)) == 0)
>                rm_unbind_lock(sp, nv);
>
>            if (nv->flags & 0x4000)
>            {
>                nv_printf(0x4, "NVRM: UnbindLock acquired for device "
>                          "%04x:%02x:%02x.0\n",
>                          nv->pci_info.domain, nv->pci_info.bus,
>                          nv->pci_info.slot);
>
>            }
>            else
>            {
>                nv_printf(0x4, "NVRM: Could not acquire UnbindLock for device "
>                          "%04x:%02x:%02x.0\n",
>                          nv->pci_info.domain, nv->pci_info.bus,
>                          nv->pci_info.slot);
>            }
>        }
>        else if ((value == 0) && (nv->flags & 0x4000))
>        {
>            nv->flags &= ~0x4000;
>            nv_printf(0x4, "NVRM: UnbindLock released for device "
>                      "%04x:%02x:%02x.0\n",
>                      nv->pci_info.domain, nv->pci_info.bus,
>                      nv->pci_info.slot);
>        }
>        up(&nvl->ldata_lock);
>    }
>
>done:
>    if (((void *)0) != nvfp->data)
>        os_free_mem(nvfp->data);
>
>    if (sp != ((void *)0))
>    {
>        nv_kmem_cache_free_stack(sp);
>        nvfp->fops_sp[NV_FOPS_STACK_INDEX_PROCFS] = ((void *)0);
>    }
>
>    nv_free_file_private(nvfp);
>
>    return rc;
>}
>
>static nv_proc_ops_t nv_procfs_unbind_lock_fops = {
>   
>    .proc_open = nv_procfs_open_unbind_lock,
>    .proc_read = seq_read,
>    .proc_write = nv_procfs_write_file,
>    .proc_lseek = seq_lseek,
>    .proc_release = nv_procfs_close_unbind_lock,
>};
>
>static int
>nv_procfs_read_text_file(
>    struct seq_file *s,
>    void *v
>)
>{
>    seq_puts(s, s->private);
>    return 0;
>}
>
>static int nv_procfs_open_text_file( struct inode *inode, struct file *filep ) { return single_open(filep, nv_procfs_read_text_file, PDE_DATA(inode)); } static const nv_proc_ops_t nv_procfs_text_file_fops = { .proc_open = nv_procfs_open_text_file, .proc_read = seq_read, .proc_lseek = seq_lseek, .proc_release = single_release, };;
>
>static void
>nv_procfs_add_text_file(
>    struct proc_dir_entry *parent,
>    const char *filename,
>    const char *text
>)
>{
>    ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_text_file_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data(filename, mode, parent, fops, (void *)text); __entry; });
>}
>
>static void
>nv_procfs_unregister_all(struct proc_dir_entry *entry, struct proc_dir_entry *delimiter)
>{
>
>    proc_remove(entry);
># 701 "/usr/src/kernel-modules/nvidia-390.157-default/nvidia/nv-procfs.c"
>}
>
>
>void nv_procfs_add_warning(
>    const char *filename,
>    const char *text
>)
>{
>
>    nv_procfs_add_text_file(proc_nvidia_warnings, filename, text);
>
>}
>
>int nv_register_procfs(void)
>{
>
>    NvU32 i = 0;
>    char nv_dir_name[20];
>    struct proc_dir_entry *entry;
>
>    if (nv_multiple_kernel_modules)
>        snprintf(nv_dir_name, sizeof(nv_dir_name),
>                 "driver/nvidia/%d", nv_module_instance);
>    else
>        snprintf(nv_dir_name, sizeof(nv_dir_name),
>                 "driver/%s", nv_device_name);
>
>    nv_dir_name[sizeof(nv_dir_name) - 1] = '\0';
>
>    proc_nvidia = ({ struct proc_dir_entry *__entry; int mode = (0040000 | (00400|00040|00004) | (00100|00010|00001)); __entry = proc_mkdir_mode(nv_dir_name, mode, ((void *)0)); __entry; });
>
>    if (!proc_nvidia)
>        goto failed;
>
>    entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_params_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("params", mode, proc_nvidia, fops, ((void *)0)); __entry; });
>    if (!entry)
>        goto failed;
>
>    entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_registry_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("registry", mode, proc_nvidia, fops, ((void *)0)); __entry; });
>    if (!entry)
>        goto failed;
>
>    proc_nvidia_warnings = ({ struct proc_dir_entry *__entry; int mode = (0040000 | (00400|00040|00004) | (00100|00010|00001)); __entry = proc_mkdir_mode("warnings", mode, proc_nvidia); __entry; });
>    if (!proc_nvidia_warnings)
>        goto failed;
>    nv_procfs_add_text_file(proc_nvidia_warnings, "README", __README_warning);
>
>    proc_nvidia_patches = ({ struct proc_dir_entry *__entry; int mode = (0040000 | (00400|00040|00004) | (00100|00010|00001)); __entry = proc_mkdir_mode("patches", mode, proc_nvidia); __entry; });
>    if (!proc_nvidia_patches)
>        goto failed;
>
>    for (i = 0; __nv_patches[i].short_description; i++)
>    {
>        nv_procfs_add_text_file(proc_nvidia_patches,
>            __nv_patches[i].short_description, __nv_patches[i].description);
>    }
>
>    nv_procfs_add_text_file(proc_nvidia_patches, "README", __README_patches);
>
>    entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_version_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("version", mode, proc_nvidia, fops, ((void *)0)); __entry; });
>    if (!entry)
>        goto failed;
>
>    proc_nvidia_gpus = ({ struct proc_dir_entry *__entry; int mode = (0040000 | (00400|00040|00004) | (00100|00010|00001)); __entry = proc_mkdir_mode("gpus", mode, proc_nvidia); __entry; });
>    if (!proc_nvidia_gpus)
>        goto failed;
>
>    return 0;
>
>failed:
>    nv_procfs_unregister_all(proc_nvidia, proc_nvidia);
>    return -1;
>
>}
>
>void nv_unregister_procfs(void)
>{
>
>    nv_procfs_unregister_all(proc_nvidia, proc_nvidia);
>
>}
>
>int nv_procfs_add_gpu(nv_linux_state_t *nvl)
>{
>
>    nv_state_t *nv;
>
>    char name[16];
>    struct proc_dir_entry *proc_nvidia_gpu, *entry;
>
>    nv = &(((nv_linux_state_t *)(nvl))->nv_state);
>
>    snprintf(name, sizeof(name), "%04x:%02x:%02x.%1x",
>                   nv->pci_info.domain, nv->pci_info.bus,
>                   nv->pci_info.slot, ((nvl->dev->devfn) & 0x07));
>
>    name[sizeof(name) - 1] = '\0';
>
>    proc_nvidia_gpu = ({ struct proc_dir_entry *__entry; int mode = (0040000 | (00400|00040|00004) | (00100|00010|00001)); __entry = proc_mkdir_mode(name, mode, proc_nvidia_gpus); __entry; });
>    if (!proc_nvidia_gpu)
>        goto failed;
>
>    entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_gpu_info_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("information", mode, proc_nvidia_gpu, fops, nv); __entry; })
>                                   ;
>    if (!entry)
>        goto failed;
>
>    entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_registry_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("registry", mode, proc_nvidia_gpu, fops, nv); __entry; });
>    if (!entry)
>        goto failed;
>
>    if ((((NvBool)(0 != 0))))
>    {
>        entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_exercise_error_forwarding_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("exercise_error_forwarding", mode, proc_nvidia_gpu, fops, nv); __entry; })
>                                                                  ;
>        if (!entry)
>            goto failed;
>    }
>
>    if (os_is_vgx_hyper())
>    {
>        entry = ({ struct proc_dir_entry *__entry; int mode = (0100000 | (00400|00040|00004)); const nv_proc_ops_t *fops = &nv_procfs_unbind_lock_fops; if (fops->proc_write != 0) mode |= 00200; __entry = proc_create_data("unbindLock", mode, proc_nvidia_gpu, fops, nv); __entry; });
>        if (!entry)
>            goto failed;
>    }
>
>    nvl->proc_dir = proc_nvidia_gpu;
>
>    return 0;
>
>failed:
>    if (proc_nvidia_gpu)
>    {
>        nv_procfs_unregister_all(proc_nvidia_gpu, proc_nvidia_gpu);
>    }
>    return -1;
>
>}
>
>void nv_procfs_remove_gpu(nv_linux_state_t *nvl)
>{
>
>    nv_procfs_unregister_all(nvl->proc_dir, nvl->proc_dir);
>
>}

Actions: View

Attachments on bug 1224402: 874943 | 875026 | 875027 | 875028 | 875072 | 875152