| // Copyright 2019 The Fuchsia Authors |
| // |
| // Use of this source code is governed by a MIT-style |
| // license that can be found in the LICENSE file or at |
| // https://opensource.org/licenses/MIT |
| |
| // This C++ file is used to validate kernel ABI types. It is compiled |
| // separately in both the kernel and user compilation environments. |
| // |
| // It produces no actual code and doesn't really need to be linked into |
| // anything. Just compiling it will statically assert that both kernel and |
| // user environments agree on the size, alignment and field offsets of various |
| // types used in the ABI. |
| // |
| // If one of these static_asserts fire, it means that a kernel type has changed |
| // in a backwards incompatible way. In other words, the change breaks ABI |
| // compatibility. |
| |
| #if defined(__aarch64__) |
| #include <lib/zircon-internal/device/cpu-trace/arm64-pm.h> |
| #elif defined(__x86_64__) |
| #include <lib/zircon-internal/device/cpu-trace/intel-pm.h> |
| #else |
| #include <lib/zircon-internal/device/cpu-trace/common-pm.h> |
| #endif |
| |
| #include <lib/zbi-format/driver-config.h> |
| #include <zircon/syscalls/clock.h> |
| #include <zircon/syscalls/debug.h> |
| #include <zircon/syscalls/exception.h> |
| #include <zircon/syscalls/hypervisor.h> |
| #include <zircon/syscalls/object.h> |
| #include <zircon/syscalls/pci.h> |
| #include <zircon/syscalls/policy.h> |
| #include <zircon/syscalls/port.h> |
| #include <zircon/syscalls/profile.h> |
| #include <zircon/syscalls/scheduler.h> |
| #include <zircon/syscalls/smc.h> |
| #include <zircon/syscalls/system.h> |
| #include <zircon/types.h> |
| |
| #include <cstddef> |
| #include <type_traits> |
| |
| // Statically asserts that type |name| has sizeof(|size|) and alignof(|alignment|). |
| #define VALIDATE_TYPE_SIZE_ALIGNMENT(name, size, alignment) \ |
| static_assert(std::is_trivial_v<name>, "ABI types must be Trivial"); \ |
| static_assert(std::is_standard_layout_v<name>, "ABI types must have a Standard Layout"); \ |
| static_assert(std::has_unique_object_representations_v<name>, \ |
| "ABI types must have unique object representations (e.g. no implicit padding)"); \ |
| static_assert(sizeof(name) == (size), "size change to " #name " breaks ABI compatibility"); \ |
| static_assert(alignof(name) == (alignment), \ |
| "alignment change to " #name " breaks ABI compatibility") |
| |
| // Statically asserts that type |name| has field |field| at offset |offset| with size |size|. |
| #define VALIDATE_FIELD_OFFSET_SIZE(name, field, offset, size) \ |
| static_assert(offsetof(name, field) == (offset), \ |
| "offset change to " #name "::" #field " breaks ABI compatibility"); \ |
| static_assert(sizeof(name::field) == (size), \ |
| "size change to " #name "::" #field " breaks ABI compatibility") |
| |
| // TODO(maniscalco): Expand the set of types validated. Validate all the ABI types, not just those |
| // with implicit padding that are copied out to usermode. |
| |
| #if defined(__aarch64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(perfmon::Arm64PmuConfig, 104, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, timebase_event, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, fixed_events, 2, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, programmable_events, 4, 12); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, fixed_initial_value, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, programmable_initial_value, 24, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, fixed_flags, 48, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, programmable_flags, 52, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuConfig, programmable_hw_events, 76, 24); |
| #elif defined(__x86_64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(perfmon::X86PmuConfig, 344, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, global_ctrl, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, fixed_ctrl, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, debug_ctrl, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, timebase_event, 24, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, fixed_events, 26, 6); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, programmable_events, 32, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, misc_events, 48, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, fixed_initial_value, 80, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, programmable_initial_value, 104, 64); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, fixed_flags, 168, 12); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, programmable_flags, 180, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, misc_flags, 212, 64); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuConfig, programmable_hw_events, 280, 64); |
| #endif |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(perfmon::PmuCommonProperties, 14, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, pm_version, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, pm_version, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, max_num_fixed_events, 2, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, max_fixed_counter_width, 4, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, max_num_programmable_events, 6, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, max_programmable_counter_width, 8, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, max_num_misc_events, 10, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::PmuCommonProperties, max_misc_counter_width, 12, 2); |
| |
| #if defined(__aarch64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(perfmon::Arm64PmuProperties, 14, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::Arm64PmuProperties, common, 0, 14); |
| #elif defined(__x86_64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(perfmon::X86PmuProperties, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuProperties, common, 0, 14); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuProperties, perf_capabilities, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(perfmon::X86PmuProperties, lbr_stack_size, 24, 4); |
| #endif |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_clock_rate_t, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_rate_t, synthetic_ticks, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_rate_t, reference_ticks, 4, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_clock_transformation_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_transformation_t, reference_offset, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_transformation_t, synthetic_offset, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_transformation_t, rate, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_clock_details_v1_t, 112, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, options, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, backstop_time, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, ticks_to_synthetic, 16, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, mono_to_synthetic, 40, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, error_bound, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, query_ticks, 72, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, last_value_update_ticks, 80, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, last_rate_adjust_update_ticks, 88, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, last_error_bounds_update_ticks, 96, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_details_v1_t, generation_counter, 104, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_clock_update_args_v1_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_update_args_v1_t, rate_adjust, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_update_args_v1_t, value, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_clock_update_args_v1_t, error_bound, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_exception_info_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_info_t, pid, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_info_t, tid, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_info_t, type, 16, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_exception_report_v1_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_report_v1_t, header, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_report_v1_t, context, 8, 24); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_exception_report_t, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_report_t, header, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_report_t, context, 8, 32); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_exception_header_t, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_header_t, size, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_header_t, type, 4, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_exception_context_v1_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_v1_t, arch, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_v1_t, arch.u, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_v1_t, arch.u.x86_64, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_v1_t, arch.u.arm_64, 0, 16); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_exception_context_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_t, arch, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_t, arch.u, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_t, arch.u.x86_64, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_t, arch.u.arm_64, 0, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_t, synth_code, 24, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_exception_context_t, synth_data, 28, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_x86_64_exc_data_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_x86_64_exc_data_t, vector, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_x86_64_exc_data_t, err_code, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_x86_64_exc_data_t, cr2, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_arm64_exc_data_v1_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_arm64_exc_data_v1_t, esr, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_arm64_exc_data_v1_t, far, 8, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_arm64_exc_data_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_arm64_exc_data_v1_t, esr, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_arm64_exc_data_v1_t, far, 8, 8); |
| |
| static_assert(sizeof(zx_x86_64_exc_data_t) == sizeof(zx_arm64_exc_data_t), |
| "zx_exception_context_* need padding update"); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_bti_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_bti_t, minimum_contiguity, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_bti_t, aspace_size, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_bti_t, pmo_count, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_bti_t, quarantine_count, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_handle_basic_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_handle_basic_t, koid, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_handle_basic_t, rights, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_handle_basic_t, type, 12, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_handle_basic_t, related_koid, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_handle_basic_t, reserved, 24, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_job_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_job_t, return_code, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_job_t, exited, 8, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_job_t, kill_on_oom, 9, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_job_t, debugger_attached, 10, 1); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_maps_mapping_t, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_mapping_t, mmu_flags, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_mapping_t, vmo_koid, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_mapping_t, vmo_offset, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_mapping_t, committed_pages, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_mapping_t, populated_pages, 32, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_maps_t, 104, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, name, 0, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, base, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, size, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, depth, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, type, 56, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, u, 64, 40); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_maps_t, u.mapping, 64, 40); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_process_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_process_t, return_code, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_process_t, start_time, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_process_t, flags, 16, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_socket_t, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_socket_t, options, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_socket_t, rx_buf_max, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_socket_t, rx_buf_size, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_socket_t, rx_buf_available, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_socket_t, tx_buf_max, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_socket_t, tx_buf_size, 40, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_thread_stats_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_thread_stats_t, total_runtime, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_thread_stats_t, last_scheduled_cpu, 8, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_task_runtime_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_task_runtime_t, cpu_time, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_task_runtime_t, queue_time, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_task_runtime_t, page_fault_time, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_task_runtime_t, lock_contention_time, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_task_runtime_v1_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_task_runtime_v1_t, cpu_time, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_task_runtime_v1_t, queue_time, 8, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_timer_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_timer_t, options, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_timer_t, deadline, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_timer_t, slack, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_vmo_t, 128, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, koid, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, name, 8, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, size_bytes, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, parent_koid, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, num_children, 56, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, num_mappings, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, share_count, 72, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, flags, 80, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, committed_bytes, 88, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, handle_rights, 96, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, cache_policy, 100, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, metadata_bytes, 104, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, committed_change_events, 112, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_t, populated_bytes, 120, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_info_vmo_v1_t, 104, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, koid, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, name, 8, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, size_bytes, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, parent_koid, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, num_children, 56, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, num_mappings, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, share_count, 72, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, flags, 80, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, committed_bytes, 88, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, handle_rights, 96, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_info_vmo_v1_t, cache_policy, 100, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_pci_bar_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_bar_t, id, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_bar_t, type, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_bar_t, size, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_bar_t, addr, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_bar_t, handle, 16, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_pci_init_arg_t, 5896, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, dev_pin_to_global_irq, 0, 4096); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, num_irqs, 4096, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, irqs, 4100, 1792); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_window_count, 5892, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0], 5896, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0].base, 5896, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0].size, 5904, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0].bus_start, 5912, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0].bus_end, 5913, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0].cfg_space_type, 5914, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pci_init_arg_t, addr_windows[0].has_ecam, 5915, 1); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_pcie_device_info_t, 12, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, vendor_id, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, device_id, 2, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, base_class, 4, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, sub_class, 5, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, program_interface, 6, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, revision_id, 7, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, bus_id, 8, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, dev_id, 9, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_pcie_device_info_t, func_id, 10, 1); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_policy_timer_slack_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_policy_timer_slack_t, min_slack, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_policy_timer_slack_t, default_mode, 8, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_port_packet_t, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, key, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, type, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, status, 12, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, user, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, signal, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, guest_bell, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, guest_mem, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, guest_io, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, guest_vcpu, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, interrupt, 16, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_port_packet_t, page_request, 16, 32); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_user_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_user_t, u64, 0, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_user_t, u32, 0, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_user_t, u16, 0, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_user_t, c8, 0, 32); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_signal_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_signal_t, trigger, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_signal_t, observed, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_signal_t, count, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_signal_t, timestamp, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_signal_t, reserved1, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_guest_bell_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_bell_t, addr, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_bell_t, reserved0, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_bell_t, reserved1, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_bell_t, reserved2, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_guest_mem_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, addr, 0, 8); |
| #if defined(__aarch64__) |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, access_size, 8, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, sign_extend, 9, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, xt, 10, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, read, 11, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, data, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, reserved, 24, 8); |
| #elif defined(__x86_64__) |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, cr3, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, rip, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, instruction_size, 24, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, default_operand_size, 25, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_mem_t, reserved, 26, 6); |
| #endif |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_guest_io_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, port, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, access_size, 2, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, input, 3, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, u8, 4, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, u16, 4, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, u32, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, data, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, reserved0, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, reserved1, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_io_t, reserved2, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_guest_vcpu_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, type, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, interrupt, 8, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, interrupt.mask, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, interrupt.vector, 16, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, startup, 8, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, startup.id, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, startup.entry, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, exit, 8, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, exit.retcode, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, exit.reserved, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_guest_vcpu_t, reserved, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_interrupt_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_interrupt_t, timestamp, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_interrupt_t, reserved0, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_interrupt_t, reserved1, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_interrupt_t, reserved2, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_packet_page_request_t, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_page_request_t, command, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_page_request_t, flags, 2, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_page_request_t, reserved0, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_page_request_t, offset, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_page_request_t, length, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_packet_page_request_t, reserved1, 24, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_sched_deadline_params_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_sched_deadline_params_t, capacity, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_sched_deadline_params_t, relative_deadline, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_sched_deadline_params_t, period, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_cpu_set_t, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_cpu_set_t, mask, 0, 64); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_profile_info_t, 96, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_profile_info_t, flags, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_profile_info_t, priority, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_profile_info_t, deadline_params, 8, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_profile_info_t, cpu_affinity_mask, 32, 64); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_smc_parameters_t, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, func_id, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, arg1, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, arg2, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, arg3, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, arg4, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, arg5, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, arg6, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, client_id, 56, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_smc_parameters_t, secure_os_id, 58, 2); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_system_powerctl_arg_t, 12, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, acpi_transition_s_state, 0, 3); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, acpi_transition_s_state.target_s_state, 0, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, acpi_transition_s_state.sleep_type_a, 1, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, acpi_transition_s_state.sleep_type_b, 2, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, x86_power_limit, 0, 12); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, x86_power_limit.power_limit, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, x86_power_limit.time_window, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, x86_power_limit.clamp, 8, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_system_powerctl_arg_t, x86_power_limit.enable, 9, 1); |
| |
| #if defined(__aarch64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_thread_state_debug_regs_t, 528, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, hw_bps, 0, 256); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, hw_bps[0].dbgbcr, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, hw_bps[0].dbgbvr, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, hw_wps, 256, 256); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, far, 512, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, esr, 520, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, hw_bps_count, 524, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, hw_wps_count, 525, 1); |
| #elif defined(__x86_64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_thread_state_debug_regs_t, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, dr, 0, 32); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, dr6, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_debug_regs_t, dr7, 40, 8); |
| #endif |
| |
| #if defined(__aarch64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_thread_state_fp_regs_t, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, unused, 0, 4); |
| #elif defined(__x86_64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_thread_state_fp_regs_t, 160, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, fcw, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, fsw, 2, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, ftw, 4, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, reserved, 5, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, fop, 6, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, fip, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, fdp, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, st, 32, 128); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, st[0].low, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_fp_regs_t, st[0].high, 40, 8); |
| #endif |
| |
| #if defined(__aarch64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_thread_state_vector_regs_t, 520, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, fpcr, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, fpsr, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, v, 8, 512); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, v[0].low, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, v[0].high, 16, 8); |
| #elif defined(__x86_64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_thread_state_vector_regs_t, 2120, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, zmm, 0, 2048); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, zmm[0].v, 0, 64); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, opmask, 2048, 64); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_thread_state_vector_regs_t, mxcsr, 2112, 4); |
| #endif |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_vcpu_io_t, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_io_t, access_size, 0, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_io_t, u8, 4, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_io_t, u16, 4, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_io_t, u32, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_io_t, data, 4, 4); |
| |
| #if defined(__aarch64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_vcpu_state_t, 264, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, x, 0, 248); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, sp, 248, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, cpsr, 256, 4); |
| #elif defined(__x86_64__) |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zx_vcpu_state_t, 136, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rax, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rcx, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rdx, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rbx, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rsp, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rbp, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rsi, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rdi, 56, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r8, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r9, 72, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r10, 80, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r11, 88, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r12, 96, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r13, 104, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r14, 112, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, r15, 120, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zx_vcpu_state_t, rflags, 128, 8); |
| #endif |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_simple_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_simple_t, mmio_phys, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_simple_t, irq, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_simple_t, reserved, 12, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_simple_pio_t, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_simple_pio_t, base, 0, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_simple_pio_t, reserved, 2, 2); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_simple_pio_t, irq, 4, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_arm_psci_driver_t, 104, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_psci_driver_t, use_hvc, 0, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_psci_driver_t, reserved, 1, 7); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_psci_driver_t, shutdown_args, 8, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_psci_driver_t, reboot_args, 32, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_psci_driver_t, reboot_bootloader_args, 56, 24); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_psci_driver_t, reboot_recovery_args, 80, 24); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_arm_gic_v2_driver_t, 56, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, mmio_phys, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, msi_frame_phys, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, gicd_offset, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, gicc_offset, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, gich_offset, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, gicv_offset, 40, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, ipi_base, 48, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, optional, 52, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, use_msi, 53, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v2_driver_t, reserved, 54, 2); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_arm_gic_v3_driver_t, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, mmio_phys, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, gicd_offset, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, gicr_offset, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, gicr_stride, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, reserved0, 32, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, ipi_base, 40, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, optional, 44, 1); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_gic_v3_driver_t, reserved1, 45, 3); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_arm_generic_timer_driver_t, 16, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_generic_timer_driver_t, irq_phys, 0, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_generic_timer_driver_t, irq_virt, 4, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_generic_timer_driver_t, irq_sphys, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_arm_generic_timer_driver_t, freq_override, 12, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_amlogic_hdcp_driver_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_amlogic_hdcp_driver_t, preset_phys, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_amlogic_hdcp_driver_t, hiu_phys, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_amlogic_hdcp_driver_t, hdmitx_phys, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_amlogic_rng_driver_t, 24, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_amlogic_rng_driver_t, rng_data_phys, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_amlogic_rng_driver_t, rng_status_phys, 8, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_amlogic_rng_driver_t, rng_refresh_interval_usec, 16, 8); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_generic32_watchdog_action_t, 16, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_action_t, addr, 0, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_action_t, clr_mask, 8, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_action_t, set_mask, 12, 4); |
| |
| VALIDATE_TYPE_SIZE_ALIGNMENT(zbi_dcfg_generic32_watchdog_t, 64, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_t, pet_action, 0, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_t, enable_action, 16, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_t, disable_action, 32, 16); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_t, watchdog_period_nsec, 48, 8); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_t, flags, 56, 4); |
| VALIDATE_FIELD_OFFSET_SIZE(zbi_dcfg_generic32_watchdog_t, reserved, 60, 4); |
| |
| #undef VALIDATE_TYPE_SIZE_ALIGNMENT |
| #undef VALIDATE_FIELD_OFFSET_SIZE |
