| // Copyright 2019 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #include <zircon/errors.h> |
| #include <zircon/syscalls/exception.h> |
| #include <zircon/syscalls/iommu.h> |
| #include <zircon/syscalls/pci.h> |
| #include <zircon/syscalls/policy.h> |
| #include <zircon/syscalls/port.h> |
| #include <zircon/syscalls/profile.h> |
| #include <zircon/syscalls/smc.h> |
| #include <zircon/syscalls/system.h> |
| |
| #include <cstdint> |
| #include <memory> |
| |
| #include "tools/fidlcat/lib/statistics.h" |
| #include "tools/fidlcat/lib/syscall_decoder_dispatcher.h" |
| |
| namespace fidlcat { |
| |
| class ZxChannelCallArgs { |
| public: |
| static const uint8_t* wr_bytes(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? nullptr : reinterpret_cast<const uint8_t*>(from->wr_bytes); |
| } |
| static const zx_handle_t* wr_handles(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? nullptr : from->wr_handles; |
| } |
| static const uint8_t* rd_bytes(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? nullptr : reinterpret_cast<const uint8_t*>(from->rd_bytes); |
| } |
| static const zx_handle_t* rd_handles(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? nullptr : from->rd_handles; |
| } |
| static uint32_t wr_num_bytes(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? 0 : from->wr_num_bytes; |
| } |
| static uint32_t wr_num_handles(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? 0 : from->wr_num_handles; |
| } |
| static uint32_t rd_num_bytes(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? 0 : from->rd_num_bytes; |
| } |
| static uint32_t rd_num_handles(const zx_channel_call_args_t* from) { |
| return (from == nullptr) ? 0 : from->rd_num_handles; |
| } |
| }; |
| |
| class ZxChannelCallEtcArgs { |
| public: |
| static const uint8_t* wr_bytes(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? nullptr : reinterpret_cast<const uint8_t*>(from->wr_bytes); |
| } |
| static const zx_handle_disposition_t* wr_handles(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? nullptr : from->wr_handles; |
| } |
| static const uint8_t* rd_bytes(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? nullptr : reinterpret_cast<const uint8_t*>(from->rd_bytes); |
| } |
| static const zx_handle_info_t* rd_handles(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? nullptr : from->rd_handles; |
| } |
| static uint32_t wr_num_bytes(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? 0 : from->wr_num_bytes; |
| } |
| static uint32_t wr_num_handles(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? 0 : from->wr_num_handles; |
| } |
| static uint32_t rd_num_bytes(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? 0 : from->rd_num_bytes; |
| } |
| static uint32_t rd_num_handles(const zx_channel_call_etc_args_t* from) { |
| return (from == nullptr) ? 0 : from->rd_num_handles; |
| } |
| }; |
| |
| class ZxX86_64ExcData : public Class<zx_x86_64_exc_data_t> { |
| public: |
| static const ZxX86_64ExcData* GetClass(); |
| |
| static uint64_t vector(const zx_x86_64_exc_data_t* from) { return from->vector; } |
| static uint64_t err_code(const zx_x86_64_exc_data_t* from) { return from->err_code; } |
| static uint64_t cr2(const zx_x86_64_exc_data_t* from) { return from->cr2; } |
| |
| private: |
| ZxX86_64ExcData() : Class("zx_x86_64_exc_data_t") { |
| AddField(std::make_unique<ClassField<zx_x86_64_exc_data_t, uint64_t>>( |
| "vector", SyscallType::kUint64, vector)); |
| AddField(std::make_unique<ClassField<zx_x86_64_exc_data_t, uint64_t>>( |
| "err_code", SyscallType::kUint64, err_code)); |
| AddField(std::make_unique<ClassField<zx_x86_64_exc_data_t, uint64_t>>( |
| "cr2", SyscallType::kUint64, cr2)); |
| } |
| ZxX86_64ExcData(const ZxX86_64ExcData&) = delete; |
| ZxX86_64ExcData& operator=(const ZxX86_64ExcData&) = delete; |
| static ZxX86_64ExcData* instance_; |
| }; |
| |
| ZxX86_64ExcData* ZxX86_64ExcData::instance_ = nullptr; |
| |
| const ZxX86_64ExcData* ZxX86_64ExcData::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxX86_64ExcData; |
| } |
| return instance_; |
| } |
| |
| class ZxArm64ExcData : public Class<zx_arm64_exc_data_t> { |
| public: |
| static const ZxArm64ExcData* GetClass(); |
| |
| static uint32_t esr(const zx_arm64_exc_data_t* from) { return from->esr; } |
| static uint64_t far(const zx_arm64_exc_data_t* from) { return from->far; } |
| |
| private: |
| ZxArm64ExcData() : Class("zx_arm64_exc_data_t") { |
| AddField(std::make_unique<ClassField<zx_arm64_exc_data_t, uint32_t>>( |
| "esr", SyscallType::kUint32, esr)); |
| AddField(std::make_unique<ClassField<zx_arm64_exc_data_t, uint64_t>>( |
| "far", SyscallType::kUint64, far)); |
| } |
| ZxArm64ExcData(const ZxArm64ExcData&) = delete; |
| ZxArm64ExcData& operator=(const ZxArm64ExcData&) = delete; |
| static ZxArm64ExcData* instance_; |
| }; |
| |
| ZxArm64ExcData* ZxArm64ExcData::instance_ = nullptr; |
| |
| const ZxArm64ExcData* ZxArm64ExcData::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxArm64ExcData; |
| } |
| return instance_; |
| } |
| |
| class ZxExceptionContext : public Class<zx_exception_context_t> { |
| public: |
| static const ZxExceptionContext* GetClass(); |
| |
| static const zx_x86_64_exc_data_t* x86_64(const zx_exception_context_t* from) { |
| return &from->arch.u.x86_64; |
| } |
| static const zx_arm64_exc_data_t* arm_64(const zx_exception_context_t* from) { |
| return &from->arch.u.arm_64; |
| } |
| static uint32_t synth_code(const zx_exception_context_t* from) { return from->synth_code; } |
| static uint32_t synth_data(const zx_exception_context_t* from) { return from->synth_data; } |
| |
| private: |
| ZxExceptionContext() : Class("zx_exception_context_t") { |
| AddField(std::make_unique<ClassClassField<zx_exception_context_t, zx_x86_64_exc_data_t>>( |
| "arch.x86_64", x86_64, ZxX86_64ExcData::GetClass())); |
| AddField(std::make_unique<ClassClassField<zx_exception_context_t, zx_arm64_exc_data_t>>( |
| "arch.arm_64", arm_64, ZxArm64ExcData::GetClass())); |
| AddField(std::make_unique<ClassField<zx_exception_context_t, uint32_t>>( |
| "synth_code", SyscallType::kUint32, synth_code)); |
| AddField(std::make_unique<ClassField<zx_exception_context_t, uint32_t>>( |
| "synth_data", SyscallType::kUint32, synth_data)); |
| } |
| ZxExceptionContext(const ZxExceptionContext&) = delete; |
| ZxExceptionContext& operator=(const ZxExceptionContext&) = delete; |
| static ZxExceptionContext* instance_; |
| }; |
| |
| ZxExceptionContext* ZxExceptionContext::instance_ = nullptr; |
| |
| const ZxExceptionContext* ZxExceptionContext::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxExceptionContext; |
| } |
| return instance_; |
| } |
| |
| class ZxExceptionHeader : public Class<zx_exception_header_t> { |
| public: |
| static const ZxExceptionHeader* GetClass(); |
| |
| static uint32_t size(const zx_exception_header_t* from) { return from->size; } |
| static zx_excp_type_t type(const zx_exception_header_t* from) { return from->type; } |
| |
| private: |
| ZxExceptionHeader() : Class("zx_exception_header_t") { |
| AddField(std::make_unique<ClassField<zx_exception_header_t, uint32_t>>( |
| "size", SyscallType::kUint32, size)); |
| AddField(std::make_unique<ClassField<zx_exception_header_t, zx_excp_type_t>>( |
| "type", SyscallType::kUint32, type)); |
| } |
| ZxExceptionHeader(const ZxExceptionHeader&) = delete; |
| ZxExceptionHeader& operator=(const ZxExceptionHeader&) = delete; |
| static ZxExceptionHeader* instance_; |
| }; |
| |
| ZxExceptionHeader* ZxExceptionHeader::instance_ = nullptr; |
| |
| const ZxExceptionHeader* ZxExceptionHeader::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxExceptionHeader; |
| } |
| return instance_; |
| } |
| |
| class ZxExceptionReport : public Class<zx_exception_report_t> { |
| public: |
| static const ZxExceptionReport* GetClass(); |
| |
| static const zx_exception_header_t* header(const zx_exception_report_t* from) { |
| return &from->header; |
| } |
| static const zx_exception_context_t* context(const zx_exception_report_t* from) { |
| return &from->context; |
| } |
| |
| private: |
| ZxExceptionReport() : Class("zx_exception_report_t") { |
| AddField(std::make_unique<ClassClassField<zx_exception_report_t, zx_exception_header_t>>( |
| "header", header, ZxExceptionHeader::GetClass())); |
| AddField(std::make_unique<ClassClassField<zx_exception_report_t, zx_exception_context_t>>( |
| "context", context, ZxExceptionContext::GetClass())); |
| } |
| ZxExceptionReport(const ZxExceptionReport&) = delete; |
| ZxExceptionReport& operator=(const ZxExceptionReport&) = delete; |
| static ZxExceptionReport* instance_; |
| }; |
| |
| ZxExceptionReport* ZxExceptionReport::instance_ = nullptr; |
| |
| const ZxExceptionReport* ZxExceptionReport::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxExceptionReport; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoBti : public Class<zx_info_bti_t> { |
| public: |
| static const ZxInfoBti* GetClass(); |
| |
| static uint64_t minimum_contiguity(const zx_info_bti_t* from) { return from->minimum_contiguity; } |
| static uint64_t aspace_size(const zx_info_bti_t* from) { return from->aspace_size; } |
| static uint64_t pmo_count(const zx_info_bti_t* from) { return from->pmo_count; } |
| static uint64_t quarantine_count(const zx_info_bti_t* from) { return from->quarantine_count; } |
| |
| private: |
| ZxInfoBti() : Class("zx_info_bti_t") { |
| AddField(std::make_unique<ClassField<zx_info_bti_t, uint64_t>>( |
| "minimum_contiguity", SyscallType::kUint64, minimum_contiguity)); |
| AddField(std::make_unique<ClassField<zx_info_bti_t, uint64_t>>( |
| "aspace_size", SyscallType::kUint64, aspace_size)); |
| AddField(std::make_unique<ClassField<zx_info_bti_t, uint64_t>>( |
| "pmo_count", SyscallType::kUint64, pmo_count)); |
| AddField(std::make_unique<ClassField<zx_info_bti_t, uint64_t>>( |
| "quarantine_count", SyscallType::kUint64, quarantine_count)); |
| } |
| ZxInfoBti(const ZxInfoBti&) = delete; |
| ZxInfoBti& operator=(const ZxInfoBti&) = delete; |
| static ZxInfoBti* instance_; |
| }; |
| |
| ZxInfoBti* ZxInfoBti::instance_ = nullptr; |
| |
| const ZxInfoBti* ZxInfoBti::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoBti; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoCpuStats : public Class<zx_info_cpu_stats_t> { |
| public: |
| static const ZxInfoCpuStats* GetClass(); |
| |
| static uint32_t cpu_number(const zx_info_cpu_stats_t* from) { return from->cpu_number; } |
| static uint32_t flags(const zx_info_cpu_stats_t* from) { return from->flags; } |
| static zx_duration_t idle_time(const zx_info_cpu_stats_t* from) { return from->idle_time; } |
| static uint64_t reschedules(const zx_info_cpu_stats_t* from) { return from->reschedules; } |
| static uint64_t context_switches(const zx_info_cpu_stats_t* from) { |
| return from->context_switches; |
| } |
| static uint64_t irq_preempts(const zx_info_cpu_stats_t* from) { return from->irq_preempts; } |
| static uint64_t preempts(const zx_info_cpu_stats_t* from) { return from->preempts; } |
| static uint64_t yields(const zx_info_cpu_stats_t* from) { return from->yields; } |
| static uint64_t ints(const zx_info_cpu_stats_t* from) { return from->ints; } |
| static uint64_t timer_ints(const zx_info_cpu_stats_t* from) { return from->timer_ints; } |
| static uint64_t timers(const zx_info_cpu_stats_t* from) { return from->timers; } |
| static uint64_t syscalls(const zx_info_cpu_stats_t* from) { return from->syscalls; } |
| static uint64_t reschedule_ipis(const zx_info_cpu_stats_t* from) { return from->reschedule_ipis; } |
| static uint64_t generic_ipis(const zx_info_cpu_stats_t* from) { return from->generic_ipis; } |
| |
| private: |
| ZxInfoCpuStats() : Class("zx_info_cpu_stats_t") { |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint32_t>>( |
| "cpu_number", SyscallType::kUint32, cpu_number)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint32_t>>( |
| "flags", SyscallType::kUint32, flags)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, zx_duration_t>>( |
| "idle_time", SyscallType::kDuration, idle_time)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "reschedules", SyscallType::kUint64, reschedules)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "context_switches", SyscallType::kUint64, context_switches)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "irq_preempts", SyscallType::kUint64, irq_preempts)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "preempts", SyscallType::kUint64, preempts)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "yields", SyscallType::kUint64, yields)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "ints", SyscallType::kUint64, ints)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "timer_ints", SyscallType::kUint64, timer_ints)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "timers", SyscallType::kUint64, timers)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "syscalls", SyscallType::kUint64, syscalls)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "reschedule_ipis", SyscallType::kUint64, reschedule_ipis)); |
| AddField(std::make_unique<ClassField<zx_info_cpu_stats_t, uint64_t>>( |
| "generic_ipis", SyscallType::kUint64, generic_ipis)); |
| } |
| ZxInfoCpuStats(const ZxInfoCpuStats&) = delete; |
| ZxInfoCpuStats& operator=(const ZxInfoCpuStats&) = delete; |
| static ZxInfoCpuStats* instance_; |
| }; |
| |
| ZxInfoCpuStats* ZxInfoCpuStats::instance_ = nullptr; |
| |
| const ZxInfoCpuStats* ZxInfoCpuStats::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoCpuStats; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoHandleBasic : public Class<zx_info_handle_basic_t> { |
| public: |
| static const ZxInfoHandleBasic* GetClass(); |
| |
| static zx_koid_t koid(const zx_info_handle_basic_t* from) { return from->koid; } |
| static zx_rights_t rights(const zx_info_handle_basic_t* from) { return from->rights; } |
| static zx_obj_type_t type(const zx_info_handle_basic_t* from) { return from->type; } |
| static zx_koid_t related_koid(const zx_info_handle_basic_t* from) { return from->related_koid; } |
| static uint32_t reserved(const zx_info_handle_basic_t* from) { return from->reserved; } |
| |
| private: |
| ZxInfoHandleBasic() : Class("zx_info_handle_basic_t") { |
| AddField(std::make_unique<ClassField<zx_info_handle_basic_t, zx_koid_t>>( |
| "koid", SyscallType::kKoid, koid)); |
| AddField(std::make_unique<ClassField<zx_info_handle_basic_t, zx_rights_t>>( |
| "rights", SyscallType::kRights, rights)); |
| AddField(std::make_unique<ClassField<zx_info_handle_basic_t, zx_obj_type_t>>( |
| "type", SyscallType::kObjType, type)); |
| AddField(std::make_unique<ClassField<zx_info_handle_basic_t, zx_koid_t>>( |
| "related_koid", SyscallType::kKoid, related_koid)); |
| } |
| ZxInfoHandleBasic(const ZxInfoHandleBasic&) = delete; |
| ZxInfoHandleBasic& operator=(const ZxInfoHandleBasic&) = delete; |
| static ZxInfoHandleBasic* instance_; |
| }; |
| |
| ZxInfoHandleBasic* ZxInfoHandleBasic::instance_ = nullptr; |
| |
| const ZxInfoHandleBasic* ZxInfoHandleBasic::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoHandleBasic; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoHandleCount : public Class<zx_info_handle_count_t> { |
| public: |
| static const ZxInfoHandleCount* GetClass(); |
| |
| static uint32_t handle_count(const zx_info_handle_count_t* from) { return from->handle_count; } |
| |
| private: |
| ZxInfoHandleCount() : Class("zx_info_handle_count_t") { |
| AddField(std::make_unique<ClassField<zx_info_handle_count_t, uint32_t>>( |
| "handle_count", SyscallType::kUint32, handle_count)); |
| } |
| ZxInfoHandleCount(const ZxInfoHandleCount&) = delete; |
| ZxInfoHandleCount& operator=(const ZxInfoHandleCount&) = delete; |
| static ZxInfoHandleCount* instance_; |
| }; |
| |
| ZxInfoHandleCount* ZxInfoHandleCount::instance_ = nullptr; |
| |
| const ZxInfoHandleCount* ZxInfoHandleCount::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoHandleCount; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoJob : public Class<zx_info_job_t> { |
| public: |
| static const ZxInfoJob* GetClass(); |
| |
| static int64_t return_code(const zx_info_job_t* from) { return from->return_code; } |
| static bool exited(const zx_info_job_t* from) { return from->exited; } |
| static bool kill_on_oom(const zx_info_job_t* from) { return from->kill_on_oom; } |
| static bool debugger_attached(const zx_info_job_t* from) { return from->debugger_attached; } |
| |
| private: |
| ZxInfoJob() : Class("zx_info_job_t") { |
| AddField(std::make_unique<ClassField<zx_info_job_t, int64_t>>( |
| "return_code", SyscallType::kInt64, return_code)); |
| AddField( |
| std::make_unique<ClassField<zx_info_job_t, bool>>("exited", SyscallType::kBool, exited)); |
| AddField(std::make_unique<ClassField<zx_info_job_t, bool>>("kill_on_oom", SyscallType::kBool, |
| kill_on_oom)); |
| AddField(std::make_unique<ClassField<zx_info_job_t, bool>>( |
| "debugger_attached", SyscallType::kBool, debugger_attached)); |
| } |
| ZxInfoJob(const ZxInfoJob&) = delete; |
| ZxInfoJob& operator=(const ZxInfoJob&) = delete; |
| static ZxInfoJob* instance_; |
| }; |
| |
| ZxInfoJob* ZxInfoJob::instance_ = nullptr; |
| |
| const ZxInfoJob* ZxInfoJob::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoJob; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoKmemStats : public Class<zx_info_kmem_stats_t> { |
| public: |
| static const ZxInfoKmemStats* GetClass(); |
| |
| static size_t total_bytes(const zx_info_kmem_stats_t* from) { return from->total_bytes; } |
| static size_t free_bytes(const zx_info_kmem_stats_t* from) { return from->free_bytes; } |
| static size_t wired_bytes(const zx_info_kmem_stats_t* from) { return from->wired_bytes; } |
| static size_t total_heap_bytes(const zx_info_kmem_stats_t* from) { |
| return from->total_heap_bytes; |
| } |
| static size_t free_heap_bytes(const zx_info_kmem_stats_t* from) { return from->free_heap_bytes; } |
| static size_t vmo_bytes(const zx_info_kmem_stats_t* from) { return from->vmo_bytes; } |
| static size_t mmu_overhead_bytes(const zx_info_kmem_stats_t* from) { |
| return from->mmu_overhead_bytes; |
| } |
| static size_t other_bytes(const zx_info_kmem_stats_t* from) { return from->other_bytes; } |
| |
| private: |
| ZxInfoKmemStats() : Class("zx_info_kmem_stats_t") { |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "total_bytes", SyscallType::kSize, total_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "free_bytes", SyscallType::kSize, free_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "wired_bytes", SyscallType::kSize, wired_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "total_heap_bytes", SyscallType::kSize, total_heap_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "free_heap_bytes", SyscallType::kSize, free_heap_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "vmo_bytes", SyscallType::kSize, vmo_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "mmu_overhead_bytes", SyscallType::kSize, mmu_overhead_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_kmem_stats_t, size_t>>( |
| "other_bytes", SyscallType::kSize, other_bytes)); |
| } |
| ZxInfoKmemStats(const ZxInfoKmemStats&) = delete; |
| ZxInfoKmemStats& operator=(const ZxInfoKmemStats&) = delete; |
| static ZxInfoKmemStats* instance_; |
| }; |
| |
| ZxInfoKmemStats* ZxInfoKmemStats::instance_ = nullptr; |
| |
| const ZxInfoKmemStats* ZxInfoKmemStats::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoKmemStats; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoMapsMapping : public Class<zx_info_maps_mapping_t> { |
| public: |
| static const ZxInfoMapsMapping* GetClass(); |
| |
| static zx_vm_option_t mmu_flags(const zx_info_maps_mapping_t* from) { return from->mmu_flags; } |
| static zx_koid_t vmo_koid(const zx_info_maps_mapping_t* from) { return from->vmo_koid; } |
| static uint64_t vmo_offset(const zx_info_maps_mapping_t* from) { return from->vmo_offset; } |
| static size_t committed_pages(const zx_info_maps_mapping_t* from) { |
| return from->committed_pages; |
| } |
| |
| private: |
| ZxInfoMapsMapping() : Class("zx_info_maps_mapping_t") { |
| AddField(std::make_unique<ClassField<zx_info_maps_mapping_t, zx_vm_option_t>>( |
| "mmu_flags", SyscallType::kVmOption, mmu_flags)); |
| AddField(std::make_unique<ClassField<zx_info_maps_mapping_t, zx_koid_t>>( |
| "vmo_koid", SyscallType::kKoid, vmo_koid)); |
| AddField(std::make_unique<ClassField<zx_info_maps_mapping_t, uint64_t>>( |
| "vmo_offset", SyscallType::kUint64, vmo_offset)); |
| AddField(std::make_unique<ClassField<zx_info_maps_mapping_t, size_t>>( |
| "committed_pages", SyscallType::kSize, committed_pages)); |
| } |
| ZxInfoMapsMapping(const ZxInfoMapsMapping&) = delete; |
| ZxInfoMapsMapping& operator=(const ZxInfoMapsMapping&) = delete; |
| static ZxInfoMapsMapping* instance_; |
| }; |
| |
| ZxInfoMapsMapping* ZxInfoMapsMapping::instance_ = nullptr; |
| |
| const ZxInfoMapsMapping* ZxInfoMapsMapping::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoMapsMapping; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoMaps : public Class<zx_info_maps_t> { |
| public: |
| static const ZxInfoMaps* GetClass(); |
| |
| static std::pair<const char*, size_t> name(const zx_info_maps_t* from) { |
| return std::make_pair(reinterpret_cast<const char*>(from->name), sizeof(from->name)); |
| } |
| static zx_vaddr_t base(const zx_info_maps_t* from) { return from->base; } |
| static size_t size(const zx_info_maps_t* from) { return from->size; } |
| static size_t depth(const zx_info_maps_t* from) { return from->depth; } |
| static zx_info_maps_type_t type(const zx_info_maps_t* from) { return from->type; } |
| static const zx_info_maps_mapping_t* mapping(const zx_info_maps_t* from) { |
| return reinterpret_cast<const zx_info_maps_mapping_t*>(&from->u.mapping); |
| } |
| |
| private: |
| ZxInfoMaps() : Class("zx_info_maps_t") { |
| AddField(std::make_unique<DynamicArrayField<zx_info_maps_t, char, size_t>>( |
| "name", SyscallType::kChar, name)); |
| AddField(std::make_unique<ClassField<zx_info_maps_t, zx_vaddr_t>>("base", SyscallType::kVaddr, |
| base)); |
| AddField( |
| std::make_unique<ClassField<zx_info_maps_t, size_t>>("size", SyscallType::kSize, size)); |
| AddField( |
| std::make_unique<ClassField<zx_info_maps_t, size_t>>("depth", SyscallType::kSize, depth)); |
| auto type_field = AddField(std::make_unique<ClassField<zx_info_maps_t, zx_info_maps_type_t>>( |
| "type", SyscallType::kInfoMapsType, type)); |
| AddField(std::make_unique<ClassClassField<zx_info_maps_t, zx_info_maps_mapping_t>>( |
| "mapping", mapping, ZxInfoMapsMapping::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_INFO_MAPS_TYPE_MAPPING); |
| } |
| ZxInfoMaps(const ZxInfoMaps&) = delete; |
| ZxInfoMaps& operator=(const ZxInfoMaps&) = delete; |
| static ZxInfoMaps* instance_; |
| }; |
| |
| ZxInfoMaps* ZxInfoMaps::instance_ = nullptr; |
| |
| const ZxInfoMaps* ZxInfoMaps::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoMaps; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoProcess : public Class<zx_info_process_t> { |
| public: |
| static const ZxInfoProcess* GetClass(); |
| |
| static int64_t return_code(const zx_info_process_t* from) { return from->return_code; } |
| static zx_time_t start_time(const zx_info_process_t* from) { return from->start_time; } |
| static zx_info_process_flags_t flags(const zx_info_process_t* from) { return from->flags; } |
| |
| private: |
| ZxInfoProcess() : Class("zx_info_process_t") { |
| AddField(std::make_unique<ClassField<zx_info_process_t, int64_t>>( |
| "return_code", SyscallType::kInt64, return_code)); |
| AddField(std::make_unique<ClassField<zx_info_process_t, zx_time_t>>( |
| "start_time", SyscallType::kTime, start_time)); |
| AddField(std::make_unique<ClassField<zx_info_process_t, zx_info_process_flags_t>>( |
| "flags", SyscallType::kUint32, flags)); |
| } |
| ZxInfoProcess(const ZxInfoProcess&) = delete; |
| ZxInfoProcess& operator=(const ZxInfoProcess&) = delete; |
| static ZxInfoProcess* instance_; |
| }; |
| |
| ZxInfoProcess* ZxInfoProcess::instance_ = nullptr; |
| |
| const ZxInfoProcess* ZxInfoProcess::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoProcess; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoProcessHandleStats : public Class<zx_info_process_handle_stats_t> { |
| public: |
| static const ZxInfoProcessHandleStats* GetClass(); |
| |
| static std::pair<const uint32_t*, int> handle_count(const zx_info_process_handle_stats_t* from) { |
| return std::make_pair(reinterpret_cast<const uint32_t*>(from->handle_count), |
| sizeof(from->handle_count) / sizeof(uint32_t)); |
| } |
| |
| private: |
| ZxInfoProcessHandleStats() : Class("zx_info_process_handle_stats_t") { |
| AddField(std::make_unique<DynamicArrayField<zx_info_process_handle_stats_t, uint32_t, int>>( |
| "handle_count", SyscallType::kUint32, handle_count)); |
| } |
| ZxInfoProcessHandleStats(const ZxInfoProcessHandleStats&) = delete; |
| ZxInfoProcessHandleStats& operator=(const ZxInfoProcessHandleStats&) = delete; |
| static ZxInfoProcessHandleStats* instance_; |
| }; |
| |
| ZxInfoProcessHandleStats* ZxInfoProcessHandleStats::instance_ = nullptr; |
| |
| const ZxInfoProcessHandleStats* ZxInfoProcessHandleStats::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoProcessHandleStats; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoResource : public Class<zx_info_resource_t> { |
| public: |
| static const ZxInfoResource* GetClass(); |
| |
| static zx_rsrc_kind_t kind(const zx_info_resource_t* from) { return from->kind; } |
| static uint32_t flags(const zx_info_resource_t* from) { return from->flags; } |
| static uint64_t base(const zx_info_resource_t* from) { return from->base; } |
| static size_t size(const zx_info_resource_t* from) { return from->size; } |
| static std::pair<const char*, size_t> name(const zx_info_resource_t* from) { |
| return std::make_pair(reinterpret_cast<const char*>(from->name), sizeof(from->name)); |
| } |
| |
| private: |
| ZxInfoResource() : Class("zx_info_resource_t") { |
| AddField(std::make_unique<ClassField<zx_info_resource_t, zx_rsrc_kind_t>>( |
| "kind", SyscallType::kRsrcKind, kind)); |
| AddField(std::make_unique<ClassField<zx_info_resource_t, uint32_t>>( |
| "flags", SyscallType::kUint32, flags)); |
| AddField(std::make_unique<ClassField<zx_info_resource_t, uint64_t>>( |
| "base", SyscallType::kUint64, base)); |
| AddField( |
| std::make_unique<ClassField<zx_info_resource_t, size_t>>("size", SyscallType::kSize, size)); |
| AddField(std::make_unique<DynamicArrayField<zx_info_resource_t, char, size_t>>( |
| "name", SyscallType::kChar, name)); |
| } |
| ZxInfoResource(const ZxInfoResource&) = delete; |
| ZxInfoResource& operator=(const ZxInfoResource&) = delete; |
| static ZxInfoResource* instance_; |
| }; |
| |
| ZxInfoResource* ZxInfoResource::instance_ = nullptr; |
| |
| const ZxInfoResource* ZxInfoResource::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoResource; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoSocket : public Class<zx_info_socket_t> { |
| public: |
| static const ZxInfoSocket* GetClass(); |
| |
| static uint32_t options(const zx_info_socket_t* from) { return from->options; } |
| static size_t rx_buf_max(const zx_info_socket_t* from) { return from->rx_buf_max; } |
| static size_t rx_buf_size(const zx_info_socket_t* from) { return from->rx_buf_size; } |
| static size_t rx_buf_available(const zx_info_socket_t* from) { return from->rx_buf_available; } |
| static size_t tx_buf_max(const zx_info_socket_t* from) { return from->tx_buf_max; } |
| static size_t tx_buf_size(const zx_info_socket_t* from) { return from->tx_buf_size; } |
| |
| private: |
| ZxInfoSocket() : Class("zx_info_socket_t") { |
| AddField(std::make_unique<ClassField<zx_info_socket_t, uint32_t>>( |
| "options", SyscallType::kUint32, options)); |
| AddField(std::make_unique<ClassField<zx_info_socket_t, size_t>>( |
| "rx_buf_max", SyscallType::kSize, rx_buf_max)); |
| AddField(std::make_unique<ClassField<zx_info_socket_t, size_t>>( |
| "rx_buf_size", SyscallType::kSize, rx_buf_size)); |
| AddField(std::make_unique<ClassField<zx_info_socket_t, size_t>>( |
| "rx_buf_available", SyscallType::kSize, rx_buf_available)); |
| AddField(std::make_unique<ClassField<zx_info_socket_t, size_t>>( |
| "tx_buf_max", SyscallType::kSize, tx_buf_max)); |
| AddField(std::make_unique<ClassField<zx_info_socket_t, size_t>>( |
| "tx_buf_size", SyscallType::kSize, tx_buf_size)); |
| } |
| ZxInfoSocket(const ZxInfoSocket&) = delete; |
| ZxInfoSocket& operator=(const ZxInfoSocket&) = delete; |
| static ZxInfoSocket* instance_; |
| }; |
| |
| ZxInfoSocket* ZxInfoSocket::instance_ = nullptr; |
| |
| const ZxInfoSocket* ZxInfoSocket::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoSocket; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoTaskStats : public Class<zx_info_task_stats_t> { |
| public: |
| static const ZxInfoTaskStats* GetClass(); |
| |
| static size_t mem_mapped_bytes(const zx_info_task_stats_t* from) { |
| return from->mem_mapped_bytes; |
| } |
| static size_t mem_private_bytes(const zx_info_task_stats_t* from) { |
| return from->mem_private_bytes; |
| } |
| static size_t mem_shared_bytes(const zx_info_task_stats_t* from) { |
| return from->mem_shared_bytes; |
| } |
| static size_t mem_scaled_shared_bytes(const zx_info_task_stats_t* from) { |
| return from->mem_scaled_shared_bytes; |
| } |
| |
| private: |
| ZxInfoTaskStats() : Class("zx_info_task_stats_t") { |
| AddField(std::make_unique<ClassField<zx_info_task_stats_t, size_t>>( |
| "mem_mapped_bytes", SyscallType::kSize, mem_mapped_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_task_stats_t, size_t>>( |
| "mem_private_bytes", SyscallType::kSize, mem_private_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_task_stats_t, size_t>>( |
| "mem_shared_bytes", SyscallType::kSize, mem_shared_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_task_stats_t, size_t>>( |
| "mem_scaled_shared_bytes", SyscallType::kSize, mem_scaled_shared_bytes)); |
| } |
| ZxInfoTaskStats(const ZxInfoTaskStats&) = delete; |
| ZxInfoTaskStats& operator=(const ZxInfoTaskStats&) = delete; |
| static ZxInfoTaskStats* instance_; |
| }; |
| |
| ZxInfoTaskStats* ZxInfoTaskStats::instance_ = nullptr; |
| |
| const ZxInfoTaskStats* ZxInfoTaskStats::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoTaskStats; |
| } |
| return instance_; |
| } |
| |
| class ZxCpuSet : public Class<zx_cpu_set_t> { |
| public: |
| static const ZxCpuSet* GetClass(); |
| |
| static std::pair<const uint64_t*, int> mask(const zx_cpu_set_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->mask), |
| sizeof(from->mask) / sizeof(uint64_t)); |
| } |
| |
| private: |
| ZxCpuSet() : Class("zx_cpu_set_t") { |
| AddField(std::make_unique<DynamicArrayField<zx_cpu_set_t, uint64_t, int>>( |
| "mask", SyscallType::kUint64Hexa, mask)); |
| } |
| ZxCpuSet(const ZxCpuSet&) = delete; |
| ZxCpuSet& operator=(const ZxCpuSet&) = delete; |
| static ZxCpuSet* instance_; |
| }; |
| |
| ZxCpuSet* ZxCpuSet::instance_ = nullptr; |
| |
| const ZxCpuSet* ZxCpuSet::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxCpuSet; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoThread : public Class<zx_info_thread_t> { |
| public: |
| static const ZxInfoThread* GetClass(); |
| |
| static uint32_t state(const zx_info_thread_t* from) { return from->state; } |
| static uint32_t wait_exception_channel_type(const zx_info_thread_t* from) { |
| return from->wait_exception_channel_type; |
| } |
| static const zx_cpu_set_t* cpu_affinity_mask(const zx_info_thread_t* from) { |
| return &from->cpu_affinity_mask; |
| } |
| |
| private: |
| ZxInfoThread() : Class("zx_info_thread_t") { |
| AddField(std::make_unique<ClassField<zx_info_thread_t, uint32_t>>( |
| "state", SyscallType::kThreadState, state)); |
| AddField(std::make_unique<ClassField<zx_info_thread_t, uint32_t>>( |
| "wait_exception_channel_type", SyscallType::kExceptionChannelType, |
| wait_exception_channel_type)); |
| AddField(std::make_unique<ClassClassField<zx_info_thread_t, zx_cpu_set_t>>( |
| "cpu_affinity_mask", cpu_affinity_mask, ZxCpuSet::GetClass())); |
| } |
| ZxInfoThread(const ZxInfoThread&) = delete; |
| ZxInfoThread& operator=(const ZxInfoThread&) = delete; |
| static ZxInfoThread* instance_; |
| }; |
| |
| ZxInfoThread* ZxInfoThread::instance_ = nullptr; |
| |
| const ZxInfoThread* ZxInfoThread::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoThread; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoThreadStats : public Class<zx_info_thread_stats_t> { |
| public: |
| static const ZxInfoThreadStats* GetClass(); |
| |
| static zx_duration_t total_runtime(const zx_info_thread_stats_t* from) { |
| return from->total_runtime; |
| } |
| static uint32_t last_scheduled_cpu(const zx_info_thread_stats_t* from) { |
| return from->last_scheduled_cpu; |
| } |
| |
| private: |
| ZxInfoThreadStats() : Class("zx_info_thread_stats_t") { |
| AddField(std::make_unique<ClassField<zx_info_thread_stats_t, zx_duration_t>>( |
| "total_runtime", SyscallType::kDuration, total_runtime)); |
| AddField(std::make_unique<ClassField<zx_info_thread_stats_t, uint32_t>>( |
| "last_scheduled_cpu", SyscallType::kUint32, last_scheduled_cpu)); |
| } |
| ZxInfoThreadStats(const ZxInfoThreadStats&) = delete; |
| ZxInfoThreadStats& operator=(const ZxInfoThreadStats&) = delete; |
| static ZxInfoThreadStats* instance_; |
| }; |
| |
| ZxInfoThreadStats* ZxInfoThreadStats::instance_ = nullptr; |
| |
| const ZxInfoThreadStats* ZxInfoThreadStats::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoThreadStats; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoTimer : public Class<zx_info_timer_t> { |
| public: |
| static const ZxInfoTimer* GetClass(); |
| |
| static uint32_t options(const zx_info_timer_t* from) { return from->options; } |
| static zx_time_t deadline(const zx_info_timer_t* from) { return from->deadline; } |
| static zx_duration_t slack(const zx_info_timer_t* from) { return from->slack; } |
| |
| private: |
| ZxInfoTimer() : Class("zx_info_timer_t") { |
| AddField(std::make_unique<ClassField<zx_info_timer_t, uint32_t>>( |
| "options", SyscallType::kUint32, options)); |
| AddField(std::make_unique<ClassField<zx_info_timer_t, zx_time_t>>( |
| "deadline", SyscallType::kMonotonicTime, deadline)); |
| AddField(std::make_unique<ClassField<zx_info_timer_t, zx_duration_t>>( |
| "slack", SyscallType::kDuration, slack)); |
| } |
| ZxInfoTimer(const ZxInfoTimer&) = delete; |
| ZxInfoTimer& operator=(const ZxInfoTimer&) = delete; |
| static ZxInfoTimer* instance_; |
| }; |
| |
| ZxInfoTimer* ZxInfoTimer::instance_ = nullptr; |
| |
| const ZxInfoTimer* ZxInfoTimer::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoTimer; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoVmar : public Class<zx_info_vmar_t> { |
| public: |
| static const ZxInfoVmar* GetClass(); |
| |
| static uintptr_t base(const zx_info_vmar_t* from) { return from->base; } |
| static size_t len(const zx_info_vmar_t* from) { return from->len; } |
| |
| private: |
| ZxInfoVmar() : Class("zx_info_vmar_t") { |
| AddField(std::make_unique<ClassField<zx_info_vmar_t, uintptr_t>>("base", SyscallType::kUintptr, |
| base)); |
| AddField(std::make_unique<ClassField<zx_info_vmar_t, size_t>>("len", SyscallType::kSize, len)); |
| } |
| ZxInfoVmar(const ZxInfoVmar&) = delete; |
| ZxInfoVmar& operator=(const ZxInfoVmar&) = delete; |
| static ZxInfoVmar* instance_; |
| }; |
| |
| ZxInfoVmar* ZxInfoVmar::instance_ = nullptr; |
| |
| const ZxInfoVmar* ZxInfoVmar::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoVmar; |
| } |
| return instance_; |
| } |
| |
| class ZxInfoVmo : public Class<zx_info_vmo_t> { |
| public: |
| static const ZxInfoVmo* GetClass(); |
| |
| static zx_koid_t koid(const zx_info_vmo_t* from) { return from->koid; } |
| static std::pair<const char*, size_t> name(const zx_info_vmo_t* from) { |
| return std::make_pair(reinterpret_cast<const char*>(from->name), sizeof(from->name)); |
| } |
| static uint64_t size_bytes(const zx_info_vmo_t* from) { return from->size_bytes; } |
| static zx_koid_t parent_koid(const zx_info_vmo_t* from) { return from->parent_koid; } |
| static size_t num_children(const zx_info_vmo_t* from) { return from->num_children; } |
| static size_t num_mappings(const zx_info_vmo_t* from) { return from->num_mappings; } |
| static size_t share_count(const zx_info_vmo_t* from) { return from->share_count; } |
| static uint32_t flags(const zx_info_vmo_t* from) { return from->flags; } |
| static uint64_t committed_bytes(const zx_info_vmo_t* from) { return from->committed_bytes; } |
| static zx_rights_t handle_rights(const zx_info_vmo_t* from) { return from->handle_rights; } |
| static uint32_t cache_policy(const zx_info_vmo_t* from) { return from->cache_policy; } |
| static uint64_t metadata_bytes(const zx_info_vmo_t* from) { return from->metadata_bytes; } |
| static uint64_t committed_change_events(const zx_info_vmo_t* from) { |
| return from->committed_change_events; |
| } |
| |
| private: |
| ZxInfoVmo() : Class("zx_info_vmo_t") { |
| AddField( |
| std::make_unique<ClassField<zx_info_vmo_t, zx_koid_t>>("koid", SyscallType::kKoid, koid)); |
| AddField(std::make_unique<DynamicArrayField<zx_info_vmo_t, char, size_t>>( |
| "name", SyscallType::kChar, name)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, uint64_t>>( |
| "size_bytes", SyscallType::kUint64, size_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, zx_koid_t>>( |
| "parent_koid", SyscallType::kKoid, parent_koid)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, size_t>>("num_children", SyscallType::kSize, |
| num_children)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, size_t>>("num_mappings", SyscallType::kSize, |
| num_mappings)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, size_t>>("share_count", SyscallType::kSize, |
| share_count)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, uint32_t>>("flags", SyscallType::kVmoType, |
| flags)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, uint64_t>>( |
| "committed_bytes", SyscallType::kUint64, committed_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, zx_rights_t>>( |
| "handle_rights", SyscallType::kRights, handle_rights)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, uint32_t>>( |
| "cache_policy", SyscallType::kCachePolicy, cache_policy)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, uint64_t>>( |
| "metadata_bytes", SyscallType::kUint64, metadata_bytes)); |
| AddField(std::make_unique<ClassField<zx_info_vmo_t, uint64_t>>( |
| "committed_change_events", SyscallType::kUint64, committed_change_events)); |
| } |
| ZxInfoVmo(const ZxInfoVmo&) = delete; |
| ZxInfoVmo& operator=(const ZxInfoVmo&) = delete; |
| static ZxInfoVmo* instance_; |
| }; |
| |
| ZxInfoVmo* ZxInfoVmo::instance_ = nullptr; |
| |
| const ZxInfoVmo* ZxInfoVmo::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxInfoVmo; |
| } |
| return instance_; |
| } |
| |
| class ZxIommuDescIntel : public Class<zx_iommu_desc_intel_t> { |
| public: |
| static const ZxIommuDescIntel* GetClass(); |
| |
| static uint64_t register_base(const zx_iommu_desc_intel_t* from) { return from->register_base; } |
| static uint16_t pci_segment(const zx_iommu_desc_intel_t* from) { return from->pci_segment; } |
| static bool whole_segment(const zx_iommu_desc_intel_t* from) { return from->whole_segment; } |
| static uint8_t scope_bytes(const zx_iommu_desc_intel_t* from) { return from->scope_bytes; } |
| static uint16_t reserved_memory_bytes(const zx_iommu_desc_intel_t* from) { |
| return from->reserved_memory_bytes; |
| } |
| |
| private: |
| ZxIommuDescIntel() : Class("zx_iommu_desc_intel_t") { |
| AddField(std::make_unique<ClassField<zx_iommu_desc_intel_t, uint64_t>>( |
| "register_base", SyscallType::kPaddr, register_base)); |
| AddField(std::make_unique<ClassField<zx_iommu_desc_intel_t, uint16_t>>( |
| "pci_segment", SyscallType::kUint16, pci_segment)); |
| AddField(std::make_unique<ClassField<zx_iommu_desc_intel_t, bool>>( |
| "whole_segment", SyscallType::kBool, whole_segment)); |
| AddField(std::make_unique<ClassField<zx_iommu_desc_intel_t, uint8_t>>( |
| "scope_bytes", SyscallType::kUint8, scope_bytes)); |
| AddField(std::make_unique<ClassField<zx_iommu_desc_intel_t, uint16_t>>( |
| "reserved_memory_bytes", SyscallType::kUint16, reserved_memory_bytes)); |
| } |
| ZxIommuDescIntel(const ZxIommuDescIntel&) = delete; |
| ZxIommuDescIntel& operator=(const ZxIommuDescIntel&) = delete; |
| static ZxIommuDescIntel* instance_; |
| }; |
| |
| ZxIommuDescIntel* ZxIommuDescIntel::instance_ = nullptr; |
| |
| const ZxIommuDescIntel* ZxIommuDescIntel::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxIommuDescIntel; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketUser : public Class<zx_packet_user_t> { |
| public: |
| static const ZxPacketUser* GetClass(); |
| |
| static std::pair<const uint64_t*, int> u64(const zx_packet_user_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->u64), |
| sizeof(from->u64) / sizeof(uint64_t)); |
| } |
| static std::pair<const uint32_t*, int> u32(const zx_packet_user_t* from) { |
| return std::make_pair(reinterpret_cast<const uint32_t*>(from->u32), |
| sizeof(from->u32) / sizeof(uint32_t)); |
| } |
| static std::pair<const uint16_t*, int> u16(const zx_packet_user_t* from) { |
| return std::make_pair(reinterpret_cast<const uint16_t*>(from->u16), |
| sizeof(from->u16) / sizeof(uint16_t)); |
| } |
| static std::pair<const uint8_t*, int> c8(const zx_packet_user_t* from) { |
| return std::make_pair(reinterpret_cast<const uint8_t*>(from->c8), |
| sizeof(from->c8) / sizeof(uint8_t)); |
| } |
| |
| private: |
| ZxPacketUser() : Class("zx_packet_user_t") { |
| AddField(std::make_unique<DynamicArrayField<zx_packet_user_t, uint64_t, int>>( |
| "u64", SyscallType::kUint64Hexa, u64)); |
| AddField(std::make_unique<DynamicArrayField<zx_packet_user_t, uint32_t, int>>( |
| "u32", SyscallType::kUint32Hexa, u32)); |
| AddField(std::make_unique<DynamicArrayField<zx_packet_user_t, uint16_t, int>>( |
| "u16", SyscallType::kUint16Hexa, u16)); |
| AddField(std::make_unique<DynamicArrayField<zx_packet_user_t, uint8_t, int>>( |
| "u8", SyscallType::kUint8Hexa, c8)); |
| } |
| ZxPacketUser(const ZxPacketUser&) = delete; |
| ZxPacketUser& operator=(const ZxPacketUser&) = delete; |
| static ZxPacketUser* instance_; |
| }; |
| |
| ZxPacketUser* ZxPacketUser::instance_ = nullptr; |
| |
| const ZxPacketUser* ZxPacketUser::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketUser; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketSignal : public Class<zx_packet_signal_t> { |
| public: |
| static const ZxPacketSignal* GetClass(); |
| |
| static zx_signals_t trigger(const zx_packet_signal_t* from) { return from->trigger; } |
| static zx_signals_t observed(const zx_packet_signal_t* from) { return from->observed; } |
| static uint64_t count(const zx_packet_signal_t* from) { return from->count; } |
| static uint64_t timestamp(const zx_packet_signal_t* from) { return from->timestamp; } |
| static uint64_t reserved1(const zx_packet_signal_t* from) { return from->reserved1; } |
| |
| private: |
| ZxPacketSignal() : Class("zx_packet_signal_t") { |
| AddField(std::make_unique<ClassField<zx_packet_signal_t, zx_signals_t>>( |
| "trigger", SyscallType::kSignals, trigger)); |
| AddField(std::make_unique<ClassField<zx_packet_signal_t, zx_signals_t>>( |
| "observed", SyscallType::kSignals, observed)); |
| AddField(std::make_unique<ClassField<zx_packet_signal_t, uint64_t>>( |
| "count", SyscallType::kUint64, count)); |
| AddField(std::make_unique<ClassField<zx_packet_signal_t, uint64_t>>( |
| "timestamp", SyscallType::kTime, timestamp)); |
| AddField(std::make_unique<ClassField<zx_packet_signal_t, uint64_t>>( |
| "reserved1", SyscallType::kUint64, reserved1)); |
| } |
| ZxPacketSignal(const ZxPacketSignal&) = delete; |
| ZxPacketSignal& operator=(const ZxPacketSignal&) = delete; |
| static ZxPacketSignal* instance_; |
| }; |
| |
| ZxPacketSignal* ZxPacketSignal::instance_ = nullptr; |
| |
| const ZxPacketSignal* ZxPacketSignal::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketSignal; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketGuestBell : public Class<zx_packet_guest_bell_t> { |
| public: |
| static const ZxPacketGuestBell* GetClass(); |
| |
| static zx_gpaddr_t addr(const zx_packet_guest_bell_t* from) { return from->addr; } |
| static uint64_t reserved0(const zx_packet_guest_bell_t* from) { return from->reserved0; } |
| static uint64_t reserved1(const zx_packet_guest_bell_t* from) { return from->reserved1; } |
| static uint64_t reserved2(const zx_packet_guest_bell_t* from) { return from->reserved2; } |
| |
| private: |
| ZxPacketGuestBell() : Class("zx_packet_guest_bell_t") { |
| AddField(std::make_unique<ClassField<zx_packet_guest_bell_t, zx_gpaddr_t>>( |
| "addr", SyscallType::kGpAddr, addr)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_bell_t, uint64_t>>( |
| "reserved0", SyscallType::kUint64, reserved0)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_bell_t, uint64_t>>( |
| "reserved1", SyscallType::kUint64, reserved1)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_bell_t, uint64_t>>( |
| "reserved2", SyscallType::kUint64, reserved2)); |
| } |
| ZxPacketGuestBell(const ZxPacketGuestBell&) = delete; |
| ZxPacketGuestBell& operator=(const ZxPacketGuestBell&) = delete; |
| static ZxPacketGuestBell* instance_; |
| }; |
| |
| ZxPacketGuestBell* ZxPacketGuestBell::instance_ = nullptr; |
| |
| const ZxPacketGuestBell* ZxPacketGuestBell::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestBell; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketGuestMemAArch64 : public Class<zx_packet_guest_mem_aarch64_t> { |
| public: |
| static const ZxPacketGuestMemAArch64* GetClass(); |
| |
| static zx_gpaddr_t addr(const zx_packet_guest_mem_aarch64_t* from) { return from->addr; } |
| static uint8_t access_size(const zx_packet_guest_mem_aarch64_t* from) { |
| return from->access_size; |
| } |
| static bool sign_extend(const zx_packet_guest_mem_aarch64_t* from) { return from->sign_extend; } |
| static uint8_t xt(const zx_packet_guest_mem_aarch64_t* from) { return from->xt; } |
| static bool read(const zx_packet_guest_mem_aarch64_t* from) { return from->read; } |
| static uint64_t data(const zx_packet_guest_mem_aarch64_t* from) { return from->data; } |
| static uint64_t reserved(const zx_packet_guest_mem_aarch64_t* from) { return from->reserved; } |
| |
| private: |
| ZxPacketGuestMemAArch64() : Class("zx_packet_guest_mem_aarch64_t") { |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, zx_gpaddr_t>>( |
| "addr", SyscallType::kGpAddr, addr)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, uint8_t>>( |
| "access_size", SyscallType::kUint8, access_size)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, bool>>( |
| "sign_extend", SyscallType::kBool, sign_extend)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, uint8_t>>( |
| "xt", SyscallType::kUint8, xt)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, bool>>( |
| "read", SyscallType::kBool, read)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, uint64_t>>( |
| "data", SyscallType::kUint64, data)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_aarch64_t, uint64_t>>( |
| "reserved", SyscallType::kUint64, reserved)); |
| } |
| ZxPacketGuestMemAArch64(const ZxPacketGuestMemAArch64&) = delete; |
| ZxPacketGuestMemAArch64& operator=(const ZxPacketGuestMemAArch64&) = delete; |
| static ZxPacketGuestMemAArch64* instance_; |
| }; |
| |
| ZxPacketGuestMemAArch64* ZxPacketGuestMemAArch64::instance_ = nullptr; |
| |
| const ZxPacketGuestMemAArch64* ZxPacketGuestMemAArch64::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestMemAArch64; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketGuestMemX86 : public Class<zx_packet_guest_mem_x86_t> { |
| public: |
| static const ZxPacketGuestMemX86* GetClass(); |
| |
| static zx_gpaddr_t addr(const zx_packet_guest_mem_x86_t* from) { return from->addr; } |
| static uint8_t inst_len(const zx_packet_guest_mem_x86_t* from) { return from->inst_len; } |
| static std::pair<const uint8_t*, int> inst_buf(const zx_packet_guest_mem_x86_t* from) { |
| return std::make_pair(reinterpret_cast<const uint8_t*>(from->inst_buf), |
| sizeof(from->inst_buf) / sizeof(uint8_t)); |
| } |
| static uint8_t default_operand_size(const zx_packet_guest_mem_x86_t* from) { |
| return from->default_operand_size; |
| } |
| static std::pair<const uint8_t*, int> reserved(const zx_packet_guest_mem_x86_t* from) { |
| return std::make_pair(reinterpret_cast<const uint8_t*>(from->reserved), |
| sizeof(from->reserved) / sizeof(uint8_t)); |
| } |
| |
| private: |
| ZxPacketGuestMemX86() : Class("zx_packet_guest_mem_x86_t") { |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_x86_t, zx_gpaddr_t>>( |
| "addr", SyscallType::kGpAddr, addr)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_x86_t, uint8_t>>( |
| "inst_len", SyscallType::kUint8, inst_len)); |
| AddField(std::make_unique<DynamicArrayField<zx_packet_guest_mem_x86_t, uint8_t, int>>( |
| "inst_buf", SyscallType::kUint8Hexa, inst_buf)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_mem_x86_t, uint8_t>>( |
| "default_operand_size", SyscallType::kUint8, default_operand_size)); |
| AddField(std::make_unique<DynamicArrayField<zx_packet_guest_mem_x86_t, uint8_t, int>>( |
| "reserved", SyscallType::kUint8Hexa, reserved)); |
| } |
| ZxPacketGuestMemX86(const ZxPacketGuestMemX86&) = delete; |
| ZxPacketGuestMemX86& operator=(const ZxPacketGuestMemX86&) = delete; |
| static ZxPacketGuestMemX86* instance_; |
| }; |
| |
| ZxPacketGuestMemX86* ZxPacketGuestMemX86::instance_ = nullptr; |
| |
| const ZxPacketGuestMemX86* ZxPacketGuestMemX86::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestMemX86; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketGuestIo : public Class<zx_packet_guest_io_t> { |
| public: |
| static const ZxPacketGuestIo* GetClass(); |
| |
| static uint16_t port(const zx_packet_guest_io_t* from) { return from->port; } |
| static uint8_t access_size(const zx_packet_guest_io_t* from) { return from->access_size; } |
| static bool input(const zx_packet_guest_io_t* from) { return from->input; } |
| static uint8_t u8(const zx_packet_guest_io_t* from) { return from->u8; } |
| static uint16_t u16(const zx_packet_guest_io_t* from) { return from->u16; } |
| static uint32_t u32(const zx_packet_guest_io_t* from) { return from->u32; } |
| static std::pair<const uint8_t*, int> data(const zx_packet_guest_io_t* from) { |
| return std::make_pair(reinterpret_cast<const uint8_t*>(from->data), |
| sizeof(from->data) / sizeof(uint8_t)); |
| } |
| static uint64_t reserved0(const zx_packet_guest_io_t* from) { return from->reserved0; } |
| static uint64_t reserved1(const zx_packet_guest_io_t* from) { return from->reserved1; } |
| static uint64_t reserved2(const zx_packet_guest_io_t* from) { return from->reserved2; } |
| |
| private: |
| ZxPacketGuestIo() : Class("zx_packet_guest_io_t") { |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint16_t>>( |
| "port", SyscallType::kUint16, port)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint8_t>>( |
| "access_size", SyscallType::kUint8, access_size)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, bool>>("input", SyscallType::kBool, |
| input)); |
| AddField( |
| std::make_unique<ClassField<zx_packet_guest_io_t, uint8_t>>("u8", SyscallType::kUint8, u8)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint16_t>>( |
| "u16", SyscallType::kUint16, u16)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint32_t>>( |
| "u32", SyscallType::kUint32, u32)); |
| AddField(std::make_unique<DynamicArrayField<zx_packet_guest_io_t, uint8_t, int>>( |
| "data", SyscallType::kUint8Hexa, data)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint64_t>>( |
| "reserved0", SyscallType::kUint64, reserved0)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint64_t>>( |
| "reserved1", SyscallType::kUint64, reserved1)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_io_t, uint64_t>>( |
| "reserved2", SyscallType::kUint64, reserved2)); |
| } |
| ZxPacketGuestIo(const ZxPacketGuestIo&) = delete; |
| ZxPacketGuestIo& operator=(const ZxPacketGuestIo&) = delete; |
| static ZxPacketGuestIo* instance_; |
| }; |
| |
| ZxPacketGuestIo* ZxPacketGuestIo::instance_ = nullptr; |
| |
| const ZxPacketGuestIo* ZxPacketGuestIo::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestIo; |
| } |
| return instance_; |
| } |
| |
| // This is extracted from zx_packet_vcpu from zircon/system/public/zircon/syscalls/port.h |
| struct zx_packet_guest_vcpu_interrupt { |
| uint64_t mask; |
| uint8_t vector; |
| }; |
| using zx_packet_guest_vcpu_interrupt_t = struct zx_packet_guest_vcpu_interrupt; |
| |
| class ZxPacketGuestVcpuInterrupt : public Class<zx_packet_guest_vcpu_interrupt_t> { |
| public: |
| static const ZxPacketGuestVcpuInterrupt* GetClass(); |
| |
| static uint64_t mask(const zx_packet_guest_vcpu_interrupt_t* from) { return from->mask; } |
| static uint8_t vector(const zx_packet_guest_vcpu_interrupt_t* from) { return from->vector; } |
| |
| private: |
| ZxPacketGuestVcpuInterrupt() : Class("zx_packet_guest_vcpu_interrupt_t") { |
| AddField(std::make_unique<ClassField<zx_packet_guest_vcpu_interrupt_t, uint64_t>>( |
| "mask", SyscallType::kUint64, mask)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_vcpu_interrupt_t, uint8_t>>( |
| "vector", SyscallType::kUint8, vector)); |
| } |
| ZxPacketGuestVcpuInterrupt(const ZxPacketGuestVcpuInterrupt&) = delete; |
| ZxPacketGuestVcpuInterrupt& operator=(const ZxPacketGuestVcpuInterrupt&) = delete; |
| static ZxPacketGuestVcpuInterrupt* instance_; |
| }; |
| |
| ZxPacketGuestVcpuInterrupt* ZxPacketGuestVcpuInterrupt::instance_ = nullptr; |
| |
| const ZxPacketGuestVcpuInterrupt* ZxPacketGuestVcpuInterrupt::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestVcpuInterrupt; |
| } |
| return instance_; |
| } |
| |
| // This is extracted from zx_packet_vcpu from zircon/system/public/zircon/syscalls/port.h |
| struct zx_packet_guest_vcpu_startup { |
| uint64_t id; |
| zx_gpaddr_t entry; |
| }; |
| using zx_packet_guest_vcpu_startup_t = struct zx_packet_guest_vcpu_startup; |
| |
| class ZxPacketGuestVcpuStartup : public Class<zx_packet_guest_vcpu_startup_t> { |
| public: |
| static const ZxPacketGuestVcpuStartup* GetClass(); |
| |
| static uint64_t id(const zx_packet_guest_vcpu_startup_t* from) { return from->id; } |
| static zx_gpaddr_t entry(const zx_packet_guest_vcpu_startup_t* from) { return from->entry; } |
| |
| private: |
| ZxPacketGuestVcpuStartup() : Class("zx_packet_guest_vcpu_startup_t") { |
| AddField(std::make_unique<ClassField<zx_packet_guest_vcpu_startup_t, uint64_t>>( |
| "id", SyscallType::kUint64, id)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_vcpu_startup_t, zx_gpaddr_t>>( |
| "entry", SyscallType::kGpAddr, entry)); |
| } |
| ZxPacketGuestVcpuStartup(const ZxPacketGuestVcpuStartup&) = delete; |
| ZxPacketGuestVcpuStartup& operator=(const ZxPacketGuestVcpuStartup&) = delete; |
| static ZxPacketGuestVcpuStartup* instance_; |
| }; |
| |
| ZxPacketGuestVcpuStartup* ZxPacketGuestVcpuStartup::instance_ = nullptr; |
| |
| const ZxPacketGuestVcpuStartup* ZxPacketGuestVcpuStartup::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestVcpuStartup; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketGuestVcpu : public Class<zx_packet_guest_vcpu_t> { |
| public: |
| static const ZxPacketGuestVcpu* GetClass(); |
| |
| static const zx_packet_guest_vcpu_interrupt_t* interrupt(const zx_packet_guest_vcpu_t* from) { |
| return reinterpret_cast<const zx_packet_guest_vcpu_interrupt_t*>(&from->interrupt); |
| } |
| static const zx_packet_guest_vcpu_startup_t* startup(const zx_packet_guest_vcpu_t* from) { |
| return reinterpret_cast<const zx_packet_guest_vcpu_startup_t*>(&from->startup); |
| } |
| static uint8_t type(const zx_packet_guest_vcpu_t* from) { return from->type; } |
| static uint64_t reserved(const zx_packet_guest_vcpu_t* from) { return from->reserved; } |
| |
| private: |
| ZxPacketGuestVcpu() : Class("zx_packet_guest_vcpu_t") { |
| auto type_field = AddField(std::make_unique<ClassField<zx_packet_guest_vcpu_t, uint8_t>>( |
| "type", SyscallType::kPacketGuestVcpuType, type)); |
| AddField( |
| std::make_unique<ClassClassField<zx_packet_guest_vcpu_t, zx_packet_guest_vcpu_interrupt_t>>( |
| "interrupt", interrupt, ZxPacketGuestVcpuInterrupt::GetClass())) |
| ->DisplayIfEqual(type_field, uint8_t(ZX_PKT_GUEST_VCPU_INTERRUPT)); |
| AddField( |
| std::make_unique<ClassClassField<zx_packet_guest_vcpu_t, zx_packet_guest_vcpu_startup_t>>( |
| "startup", startup, ZxPacketGuestVcpuStartup::GetClass())) |
| ->DisplayIfEqual(type_field, uint8_t(ZX_PKT_GUEST_VCPU_STARTUP)); |
| AddField(std::make_unique<ClassField<zx_packet_guest_vcpu_t, uint64_t>>( |
| "reserved", SyscallType::kUint64, reserved)); |
| } |
| ZxPacketGuestVcpu(const ZxPacketGuestVcpu&) = delete; |
| ZxPacketGuestVcpu& operator=(const ZxPacketGuestVcpu&) = delete; |
| static ZxPacketGuestVcpu* instance_; |
| }; |
| |
| ZxPacketGuestVcpu* ZxPacketGuestVcpu::instance_ = nullptr; |
| |
| const ZxPacketGuestVcpu* ZxPacketGuestVcpu::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketGuestVcpu; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketInterrupt : public Class<zx_packet_interrupt_t> { |
| public: |
| static const ZxPacketInterrupt* GetClass(); |
| |
| static zx_time_t timestamp(const zx_packet_interrupt_t* from) { return from->timestamp; } |
| static uint64_t reserved0(const zx_packet_interrupt_t* from) { return from->reserved0; } |
| static uint64_t reserved1(const zx_packet_interrupt_t* from) { return from->reserved1; } |
| static uint64_t reserved2(const zx_packet_interrupt_t* from) { return from->reserved2; } |
| |
| private: |
| ZxPacketInterrupt() : Class("zx_packet_interrupt_t") { |
| AddField(std::make_unique<ClassField<zx_packet_interrupt_t, zx_time_t>>( |
| "timestamp", SyscallType::kTime, timestamp)); |
| AddField(std::make_unique<ClassField<zx_packet_interrupt_t, uint64_t>>( |
| "reserved0", SyscallType::kUint64, reserved0)); |
| AddField(std::make_unique<ClassField<zx_packet_interrupt_t, uint64_t>>( |
| "reserved1", SyscallType::kUint64, reserved1)); |
| AddField(std::make_unique<ClassField<zx_packet_interrupt_t, uint64_t>>( |
| "reserved2", SyscallType::kUint64, reserved2)); |
| } |
| ZxPacketInterrupt(const ZxPacketInterrupt&) = delete; |
| ZxPacketInterrupt& operator=(const ZxPacketInterrupt&) = delete; |
| static ZxPacketInterrupt* instance_; |
| }; |
| |
| ZxPacketInterrupt* ZxPacketInterrupt::instance_ = nullptr; |
| |
| const ZxPacketInterrupt* ZxPacketInterrupt::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketInterrupt; |
| } |
| return instance_; |
| } |
| |
| class ZxPacketPageRequest : public Class<zx_packet_page_request_t> { |
| public: |
| static const ZxPacketPageRequest* GetClass(); |
| |
| static uint16_t command(const zx_packet_page_request_t* from) { return from->command; } |
| static uint16_t flags(const zx_packet_page_request_t* from) { return from->flags; } |
| static uint32_t reserved0(const zx_packet_page_request_t* from) { return from->reserved0; } |
| static uint64_t offset(const zx_packet_page_request_t* from) { return from->offset; } |
| static uint64_t length(const zx_packet_page_request_t* from) { return from->length; } |
| static uint64_t reserved1(const zx_packet_page_request_t* from) { return from->reserved1; } |
| |
| private: |
| ZxPacketPageRequest() : Class("zx_packet_page_request_t") { |
| AddField(std::make_unique<ClassField<zx_packet_page_request_t, uint16_t>>( |
| "command", SyscallType::kPacketPageRequestCommand, command)); |
| AddField(std::make_unique<ClassField<zx_packet_page_request_t, uint16_t>>( |
| "flags", SyscallType::kUint16, flags)); |
| AddField(std::make_unique<ClassField<zx_packet_page_request_t, uint32_t>>( |
| "reserved0", SyscallType::kUint32, reserved0)); |
| AddField(std::make_unique<ClassField<zx_packet_page_request_t, uint64_t>>( |
| "offset", SyscallType::kUint64, offset)); |
| AddField(std::make_unique<ClassField<zx_packet_page_request_t, uint64_t>>( |
| "length", SyscallType::kUint64, length)); |
| AddField(std::make_unique<ClassField<zx_packet_page_request_t, uint64_t>>( |
| "reserved1", SyscallType::kUint64, reserved1)); |
| } |
| ZxPacketPageRequest(const ZxPacketPageRequest&) = delete; |
| ZxPacketPageRequest& operator=(const ZxPacketPageRequest&) = delete; |
| static ZxPacketPageRequest* instance_; |
| }; |
| |
| ZxPacketPageRequest* ZxPacketPageRequest::instance_ = nullptr; |
| |
| const ZxPacketPageRequest* ZxPacketPageRequest::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPacketPageRequest; |
| } |
| return instance_; |
| } |
| |
| class ZxPciBar : public Class<zx_pci_bar_t> { |
| public: |
| static const ZxPciBar* GetClass(); |
| |
| static uint32_t id(const zx_pci_bar_t* from) { return from->id; } |
| static uint32_t type(const zx_pci_bar_t* from) { return from->type; } |
| static size_t size(const zx_pci_bar_t* from) { return from->size; } |
| static uintptr_t addr(const zx_pci_bar_t* from) { return from->addr; } |
| static zx_handle_t handle(const zx_pci_bar_t* from) { return from->handle; } |
| |
| private: |
| ZxPciBar() : Class("zx_pci_bar_t") { |
| AddField(std::make_unique<ClassField<zx_pci_bar_t, uint32_t>>("id", SyscallType::kUint32, id)); |
| auto type_field = AddField(std::make_unique<ClassField<zx_pci_bar_t, uint32_t>>( |
| "type", SyscallType::kPciBarType, type)); |
| AddField(std::make_unique<ClassField<zx_pci_bar_t, size_t>>("size", SyscallType::kSize, size)) |
| ->DisplayIfEqual(type_field, uint32_t(ZX_PCI_BAR_TYPE_PIO)); |
| AddField( |
| std::make_unique<ClassField<zx_pci_bar_t, uintptr_t>>("addr", SyscallType::kUintptr, addr)) |
| ->DisplayIfEqual(type_field, uint32_t(ZX_PCI_BAR_TYPE_PIO)); |
| AddField(std::make_unique<ClassField<zx_pci_bar_t, zx_handle_t>>("handle", SyscallType::kHandle, |
| handle)) |
| ->DisplayIfEqual(type_field, uint32_t(ZX_PCI_BAR_TYPE_MMIO)); |
| } |
| ZxPciBar(const ZxPciBar&) = delete; |
| ZxPciBar& operator=(const ZxPciBar&) = delete; |
| static ZxPciBar* instance_; |
| }; |
| |
| ZxPciBar* ZxPciBar::instance_ = nullptr; |
| |
| const ZxPciBar* ZxPciBar::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPciBar; |
| } |
| return instance_; |
| } |
| |
| class ZxPcieDeviceInfo : public Class<zx_pcie_device_info_t> { |
| public: |
| static const ZxPcieDeviceInfo* GetClass(); |
| |
| static uint16_t vendor_id(const zx_pcie_device_info_t* from) { return from->vendor_id; } |
| static uint16_t device_id(const zx_pcie_device_info_t* from) { return from->device_id; } |
| static uint8_t base_class(const zx_pcie_device_info_t* from) { return from->base_class; } |
| static uint8_t sub_class(const zx_pcie_device_info_t* from) { return from->sub_class; } |
| static uint8_t program_interface(const zx_pcie_device_info_t* from) { |
| return from->program_interface; |
| } |
| static uint8_t revision_id(const zx_pcie_device_info_t* from) { return from->revision_id; } |
| static uint8_t bus_id(const zx_pcie_device_info_t* from) { return from->bus_id; } |
| static uint8_t dev_id(const zx_pcie_device_info_t* from) { return from->dev_id; } |
| static uint8_t func_id(const zx_pcie_device_info_t* from) { return from->func_id; } |
| |
| private: |
| ZxPcieDeviceInfo() : Class("zx_pcie_device_info_t") { |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint16_t>>( |
| "vendor_id", SyscallType::kUint16, vendor_id)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint16_t>>( |
| "device_id", SyscallType::kUint16, device_id)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "base_class", SyscallType::kUint8, base_class)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "sub_class", SyscallType::kUint8, sub_class)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "program_interface", SyscallType::kUint8, program_interface)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "revision_id", SyscallType::kUint8, revision_id)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "bus_id", SyscallType::kUint8, bus_id)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "dev_id", SyscallType::kUint8, dev_id)); |
| AddField(std::make_unique<ClassField<zx_pcie_device_info_t, uint8_t>>( |
| "func_id", SyscallType::kUint8, func_id)); |
| } |
| ZxPcieDeviceInfo(const ZxPcieDeviceInfo&) = delete; |
| ZxPcieDeviceInfo& operator=(const ZxPcieDeviceInfo&) = delete; |
| static ZxPcieDeviceInfo* instance_; |
| }; |
| |
| ZxPcieDeviceInfo* ZxPcieDeviceInfo::instance_ = nullptr; |
| |
| const ZxPcieDeviceInfo* ZxPcieDeviceInfo::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPcieDeviceInfo; |
| } |
| return instance_; |
| } |
| |
| class ZxPciInitArgIrq : public Class<zx_pci_init_arg_irq_t> { |
| public: |
| static const ZxPciInitArgIrq* GetClass(); |
| |
| static uint32_t global_irq(const zx_pci_init_arg_irq_t* from) { return from->global_irq; } |
| static bool level_triggered(const zx_pci_init_arg_irq_t* from) { return from->level_triggered; } |
| static bool active_high(const zx_pci_init_arg_irq_t* from) { return from->active_high; } |
| |
| private: |
| ZxPciInitArgIrq() : Class("zx_pci_init_arg_irq_t") { |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_irq_t, uint32_t>>( |
| "global_irq", SyscallType::kUint32, global_irq)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_irq_t, bool>>( |
| "level_triggered", SyscallType::kBool, level_triggered)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_irq_t, bool>>( |
| "active_high", SyscallType::kBool, active_high)); |
| } |
| ZxPciInitArgIrq(const ZxPciInitArgIrq&) = delete; |
| ZxPciInitArgIrq& operator=(const ZxPciInitArgIrq&) = delete; |
| static ZxPciInitArgIrq* instance_; |
| }; |
| |
| ZxPciInitArgIrq* ZxPciInitArgIrq::instance_ = nullptr; |
| |
| const ZxPciInitArgIrq* ZxPciInitArgIrq::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPciInitArgIrq; |
| } |
| return instance_; |
| } |
| |
| class ZxPciInitArgAddrWindow : public Class<zx_pci_init_arg_addr_window_t> { |
| public: |
| static const ZxPciInitArgAddrWindow* GetClass(); |
| |
| static uint64_t base(const zx_pci_init_arg_addr_window_t* from) { return from->base; } |
| static size_t size(const zx_pci_init_arg_addr_window_t* from) { return from->size; } |
| static uint8_t bus_start(const zx_pci_init_arg_addr_window_t* from) { return from->bus_start; } |
| static uint8_t bus_end(const zx_pci_init_arg_addr_window_t* from) { return from->bus_end; } |
| static uint8_t cfg_space_type(const zx_pci_init_arg_addr_window_t* from) { |
| return from->cfg_space_type; |
| } |
| static bool has_ecam(const zx_pci_init_arg_addr_window_t* from) { return from->has_ecam; } |
| |
| private: |
| ZxPciInitArgAddrWindow() : Class("zx_pci_init_arg_addr_window_t") { |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_addr_window_t, uint64_t>>( |
| "base", SyscallType::kUint64, base)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_addr_window_t, size_t>>( |
| "size", SyscallType::kSize, size)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_addr_window_t, uint8_t>>( |
| "bus_start", SyscallType::kUint8, bus_start)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_addr_window_t, uint8_t>>( |
| "bus_end", SyscallType::kUint8, bus_end)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_addr_window_t, uint8_t>>( |
| "cfg_space_type", SyscallType::kUint8, cfg_space_type)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_addr_window_t, bool>>( |
| "has_ecam", SyscallType::kBool, has_ecam)); |
| } |
| ZxPciInitArgAddrWindow(const ZxPciInitArgAddrWindow&) = delete; |
| ZxPciInitArgAddrWindow& operator=(const ZxPciInitArgAddrWindow&) = delete; |
| static ZxPciInitArgAddrWindow* instance_; |
| }; |
| |
| ZxPciInitArgAddrWindow* ZxPciInitArgAddrWindow::instance_ = nullptr; |
| |
| const ZxPciInitArgAddrWindow* ZxPciInitArgAddrWindow::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPciInitArgAddrWindow; |
| } |
| return instance_; |
| } |
| |
| class ZxPciInitArg : public Class<zx_pci_init_arg_t> { |
| public: |
| static const ZxPciInitArg* GetClass(); |
| |
| static std::pair<const uint32_t*, int> dev_pin_to_global_irq(const zx_pci_init_arg_t* from) { |
| return std::make_pair(reinterpret_cast<const uint32_t*>(from->dev_pin_to_global_irq), |
| sizeof(from->dev_pin_to_global_irq) / sizeof(uint32_t)); |
| } |
| static uint32_t num_irqs(const zx_pci_init_arg_t* from) { return from->num_irqs; } |
| static const zx_pci_init_arg_irq_t* irqs(const zx_pci_init_arg_t* from) { |
| return reinterpret_cast<const zx_pci_init_arg_irq_t*>(from->irqs); |
| } |
| static uint32_t addr_window_count(const zx_pci_init_arg_t* from) { |
| return from->addr_window_count; |
| } |
| static const zx_pci_init_arg_addr_window_t* addr_windows(const zx_pci_init_arg_t* from) { |
| return reinterpret_cast<const zx_pci_init_arg_addr_window_t*>(from->addr_windows); |
| } |
| |
| private: |
| ZxPciInitArg() : Class("zx_pci_init_arg_t") { |
| AddField(std::make_unique<ArrayField<zx_pci_init_arg_t, uint32_t>>( |
| "dev_pin_to_global_irq", SyscallType::kUint32Hexa, dev_pin_to_global_irq)); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_t, uint32_t>>( |
| "num_irqs", SyscallType::kUint32, num_irqs)); |
| AddField(std::make_unique<DynamicArrayClassField<zx_pci_init_arg_t, zx_pci_init_arg_irq_t>>( |
| "irqs", irqs, num_irqs, ZxPciInitArgIrq::GetClass())); |
| AddField(std::make_unique<ClassField<zx_pci_init_arg_t, uint32_t>>( |
| "addr_window_count", SyscallType::kUint32, addr_window_count)); |
| AddField( |
| std::make_unique<DynamicArrayClassField<zx_pci_init_arg_t, zx_pci_init_arg_addr_window_t>>( |
| "addr_windows", addr_windows, addr_window_count, ZxPciInitArgAddrWindow::GetClass())); |
| } |
| ZxPciInitArg(const ZxPciInitArg&) = delete; |
| ZxPciInitArg& operator=(const ZxPciInitArg&) = delete; |
| static ZxPciInitArg* instance_; |
| }; |
| |
| ZxPciInitArg* ZxPciInitArg::instance_ = nullptr; |
| |
| const ZxPciInitArg* ZxPciInitArg::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPciInitArg; |
| } |
| return instance_; |
| } |
| |
| class ZxPolicyBasic : public Class<zx_policy_basic_t> { |
| public: |
| static const ZxPolicyBasic* GetClass(); |
| |
| static uint32_t condition(const zx_policy_basic_t* from) { return from->condition; } |
| static uint32_t policy(const zx_policy_basic_t* from) { return from->policy; } |
| |
| private: |
| ZxPolicyBasic() : Class("zx_policy_basic_t") { |
| AddField(std::make_unique<ClassField<zx_policy_basic_t, uint32_t>>( |
| "condition", SyscallType::kPolicyCondition, condition)); |
| AddField(std::make_unique<ClassField<zx_policy_basic_t, uint32_t>>( |
| "policy", SyscallType::kPolicyAction, policy)); |
| } |
| ZxPolicyBasic(const ZxPolicyBasic&) = delete; |
| ZxPolicyBasic& operator=(const ZxPolicyBasic&) = delete; |
| static ZxPolicyBasic* instance_; |
| }; |
| |
| ZxPolicyBasic* ZxPolicyBasic::instance_ = nullptr; |
| |
| const ZxPolicyBasic* ZxPolicyBasic::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPolicyBasic; |
| } |
| return instance_; |
| } |
| |
| class ZxPolicyTimerSlack : public Class<zx_policy_timer_slack_t> { |
| public: |
| static const ZxPolicyTimerSlack* GetClass(); |
| |
| static zx_duration_t min_slack(const zx_policy_timer_slack_t* from) { return from->min_slack; } |
| static uint32_t default_mode(const zx_policy_timer_slack_t* from) { return from->default_mode; } |
| |
| private: |
| ZxPolicyTimerSlack() : Class("zx_policy_timer_slack_t") { |
| AddField(std::make_unique<ClassField<zx_policy_timer_slack_t, zx_duration_t>>( |
| "min_slack", SyscallType::kDuration, min_slack)); |
| AddField(std::make_unique<ClassField<zx_policy_timer_slack_t, uint32_t>>( |
| "default_mode", SyscallType::kTimerOption, default_mode)); |
| } |
| ZxPolicyTimerSlack(const ZxPolicyTimerSlack&) = delete; |
| ZxPolicyTimerSlack& operator=(const ZxPolicyTimerSlack&) = delete; |
| static ZxPolicyTimerSlack* instance_; |
| }; |
| |
| ZxPolicyTimerSlack* ZxPolicyTimerSlack::instance_ = nullptr; |
| |
| const ZxPolicyTimerSlack* ZxPolicyTimerSlack::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPolicyTimerSlack; |
| } |
| return instance_; |
| } |
| |
| class ZxPortPacket : public Class<zx_port_packet_t> { |
| public: |
| static const ZxPortPacket* GetClass(); |
| |
| static uint64_t key(const zx_port_packet_t* from) { return from->key; } |
| static uint32_t type(const zx_port_packet_t* from) { return from->type; } |
| static zx_status_t status(const zx_port_packet_t* from) { return from->status; } |
| static const zx_packet_user_t* user(const zx_port_packet_t* from) { return &from->user; } |
| static const zx_packet_signal_t* signal(const zx_port_packet_t* from) { return &from->signal; } |
| static const zx_packet_guest_bell_t* guest_bell(const zx_port_packet_t* from) { |
| return &from->guest_bell; |
| } |
| static const zx_packet_guest_mem_aarch64_t* guest_mem_aarch64(const zx_port_packet_t* from) { |
| return reinterpret_cast<const zx_packet_guest_mem_aarch64_t*>(&from->guest_mem); |
| } |
| static const zx_packet_guest_mem_x86_t* guest_mem_x86(const zx_port_packet_t* from) { |
| return reinterpret_cast<const zx_packet_guest_mem_x86_t*>(&from->guest_mem); |
| } |
| static const zx_packet_guest_io_t* guest_io(const zx_port_packet_t* from) { |
| return &from->guest_io; |
| } |
| static const zx_packet_guest_vcpu_t* guest_vcpu(const zx_port_packet_t* from) { |
| return &from->guest_vcpu; |
| } |
| static const zx_packet_interrupt_t* interrupt(const zx_port_packet_t* from) { |
| return &from->interrupt; |
| } |
| static const zx_packet_page_request_t* page_request(const zx_port_packet_t* from) { |
| return &from->page_request; |
| } |
| |
| private: |
| ZxPortPacket() : Class("zx_port_packet_t") { |
| // Conditional field Ids |
| const uint32_t kZxPortPacket_ZX_PKT_TYPE_GUEST_MEM_Arm64 = 1; |
| const uint32_t kZxPortPacket_ZX_PKT_TYPE_GUEST_MEM_X64 = 2; |
| // Fields |
| AddField( |
| std::make_unique<ClassField<zx_port_packet_t, uint64_t>>("key", SyscallType::kUint64, key)); |
| auto type_field = AddField(std::make_unique<ClassField<zx_port_packet_t, uint32_t>>( |
| "type", SyscallType::kPortPacketType, type)); |
| AddField(std::make_unique<ClassField<zx_port_packet_t, zx_status_t>>( |
| "status", SyscallType::kStatus, status)); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_user_t>>( |
| "user", user, ZxPacketUser::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_USER); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_signal_t>>( |
| "signal", signal, ZxPacketSignal::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_SIGNAL_ONE); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_guest_bell_t>>( |
| "guest_bell", guest_bell, ZxPacketGuestBell::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_GUEST_BELL); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_guest_mem_aarch64_t>>( |
| "guest_mem", guest_mem_aarch64, ZxPacketGuestMemAArch64::GetClass()), |
| kZxPortPacket_ZX_PKT_TYPE_GUEST_MEM_Arm64) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_GUEST_MEM) |
| ->DisplayIfArch(debug::Arch::kArm64); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_guest_mem_x86_t>>( |
| "guest_mem", guest_mem_x86, ZxPacketGuestMemX86::GetClass()), |
| kZxPortPacket_ZX_PKT_TYPE_GUEST_MEM_X64) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_GUEST_MEM) |
| ->DisplayIfArch(debug::Arch::kX64); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_guest_io_t>>( |
| "guest_io", guest_io, ZxPacketGuestIo::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_GUEST_IO); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_guest_vcpu_t>>( |
| "guest_vcpu", guest_vcpu, ZxPacketGuestVcpu::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_GUEST_VCPU); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_interrupt_t>>( |
| "interrupt", interrupt, ZxPacketInterrupt::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_INTERRUPT); |
| AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_page_request_t>>( |
| "page_request", page_request, ZxPacketPageRequest::GetClass())) |
| ->DisplayIfEqual(type_field, ZX_PKT_TYPE_PAGE_REQUEST); |
| } |
| ZxPortPacket(const ZxPortPacket&) = delete; |
| ZxPortPacket& operator=(const ZxPortPacket&) = delete; |
| static ZxPortPacket* instance_; |
| }; |
| |
| ZxPortPacket* ZxPortPacket::instance_ = nullptr; |
| |
| const ZxPortPacket* ZxPortPacket::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxPortPacket; |
| } |
| return instance_; |
| } |
| |
| class ZxProfileInfo : public Class<zx_profile_info_t> { |
| public: |
| static const ZxProfileInfo* GetClass(); |
| |
| static uint32_t flags(const zx_profile_info_t* from) { return from->flags; } |
| static int32_t priority(const zx_profile_info_t* from) { return from->priority; } |
| static const zx_cpu_set_t* cpu_affinity_mask(const zx_profile_info_t* from) { |
| return &from->cpu_affinity_mask; |
| } |
| |
| private: |
| ZxProfileInfo() : Class("zx_profile_info_t") { |
| AddField(std::make_unique<ClassField<zx_profile_info_t, uint32_t>>( |
| "flags", SyscallType::kProfileInfoFlags, flags)); |
| AddField(std::make_unique<ClassField<zx_profile_info_t, int32_t>>( |
| "priority", SyscallType::kInt32, priority)); |
| AddField(std::make_unique<ClassClassField<zx_profile_info_t, zx_cpu_set_t>>( |
| "cpu_affinity_mask", cpu_affinity_mask, ZxCpuSet::GetClass())); |
| } |
| ZxProfileInfo(const ZxProfileInfo&) = delete; |
| ZxProfileInfo& operator=(const ZxProfileInfo&) = delete; |
| static ZxProfileInfo* instance_; |
| }; |
| |
| ZxProfileInfo* ZxProfileInfo::instance_ = nullptr; |
| |
| const ZxProfileInfo* ZxProfileInfo::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxProfileInfo; |
| } |
| return instance_; |
| } |
| |
| class ZxSmcParameters : public Class<zx_smc_parameters_t> { |
| public: |
| static const ZxSmcParameters* GetClass(); |
| |
| static uint32_t func_id(const zx_smc_parameters_t* from) { return from->func_id; } |
| static uint64_t arg1(const zx_smc_parameters_t* from) { return from->arg1; } |
| static uint64_t arg2(const zx_smc_parameters_t* from) { return from->arg2; } |
| static uint64_t arg3(const zx_smc_parameters_t* from) { return from->arg3; } |
| static uint64_t arg4(const zx_smc_parameters_t* from) { return from->arg4; } |
| static uint64_t arg5(const zx_smc_parameters_t* from) { return from->arg5; } |
| static uint64_t arg6(const zx_smc_parameters_t* from) { return from->arg6; } |
| static uint16_t client_id(const zx_smc_parameters_t* from) { return from->client_id; } |
| static uint16_t secure_os_id(const zx_smc_parameters_t* from) { return from->secure_os_id; } |
| |
| private: |
| ZxSmcParameters() : Class("zx_smc_parameters_t") { |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint32_t>>( |
| "func_id", SyscallType::kUint32, func_id)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint64_t>>( |
| "arg1", SyscallType::kUint64, arg1)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint64_t>>( |
| "arg2", SyscallType::kUint64, arg2)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint64_t>>( |
| "arg3", SyscallType::kUint64, arg3)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint64_t>>( |
| "arg4", SyscallType::kUint64, arg4)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint64_t>>( |
| "arg5", SyscallType::kUint64, arg5)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint64_t>>( |
| "arg6", SyscallType::kUint64, arg6)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint16_t>>( |
| "client_id", SyscallType::kUint16, client_id)); |
| AddField(std::make_unique<ClassField<zx_smc_parameters_t, uint16_t>>( |
| "secure_os_id", SyscallType::kUint16, secure_os_id)); |
| } |
| ZxSmcParameters(const ZxSmcParameters&) = delete; |
| ZxSmcParameters& operator=(const ZxSmcParameters&) = delete; |
| static ZxSmcParameters* instance_; |
| }; |
| |
| ZxSmcParameters* ZxSmcParameters::instance_ = nullptr; |
| |
| const ZxSmcParameters* ZxSmcParameters::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxSmcParameters; |
| } |
| return instance_; |
| } |
| |
| class ZxSmcResult : public Class<zx_smc_result_t> { |
| public: |
| static const ZxSmcResult* GetClass(); |
| |
| static uint64_t arg0(const zx_smc_result_t* from) { return from->arg0; } |
| static uint64_t arg1(const zx_smc_result_t* from) { return from->arg1; } |
| static uint64_t arg2(const zx_smc_result_t* from) { return from->arg2; } |
| static uint64_t arg3(const zx_smc_result_t* from) { return from->arg3; } |
| static uint64_t arg6(const zx_smc_result_t* from) { return from->arg6; } |
| |
| private: |
| ZxSmcResult() : Class("zx_smc_result_t") { |
| AddField(std::make_unique<ClassField<zx_smc_result_t, uint64_t>>("arg0", SyscallType::kUint64, |
| arg0)); |
| AddField(std::make_unique<ClassField<zx_smc_result_t, uint64_t>>("arg1", SyscallType::kUint64, |
| arg1)); |
| AddField(std::make_unique<ClassField<zx_smc_result_t, uint64_t>>("arg2", SyscallType::kUint64, |
| arg2)); |
| AddField(std::make_unique<ClassField<zx_smc_result_t, uint64_t>>("arg3", SyscallType::kUint64, |
| arg3)); |
| AddField(std::make_unique<ClassField<zx_smc_result_t, uint64_t>>("arg6", SyscallType::kUint64, |
| arg6)); |
| } |
| ZxSmcResult(const ZxSmcResult&) = delete; |
| ZxSmcResult& operator=(const ZxSmcResult&) = delete; |
| static ZxSmcResult* instance_; |
| }; |
| |
| ZxSmcResult* ZxSmcResult::instance_ = nullptr; |
| |
| const ZxSmcResult* ZxSmcResult::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxSmcResult; |
| } |
| return instance_; |
| } |
| |
| class ZxSystemPowerctlArgAcpi : public Class<zx_system_powerctl_arg_t> { |
| public: |
| static const ZxSystemPowerctlArgAcpi* GetClass(); |
| |
| static uint8_t target_s_state(const zx_system_powerctl_arg_t* from) { |
| return from->acpi_transition_s_state.target_s_state; |
| } |
| static uint8_t sleep_type_a(const zx_system_powerctl_arg_t* from) { |
| return from->acpi_transition_s_state.sleep_type_a; |
| } |
| static uint8_t sleep_type_b(const zx_system_powerctl_arg_t* from) { |
| return from->acpi_transition_s_state.sleep_type_b; |
| } |
| |
| private: |
| ZxSystemPowerctlArgAcpi() : Class("zx_system_powerctl_arg_t") { |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint8_t>>( |
| "target_s_state", SyscallType::kUint8, target_s_state)); |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint8_t>>( |
| "sleep_type_a", SyscallType::kUint8, sleep_type_a)); |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint8_t>>( |
| "sleep_type_b", SyscallType::kUint8, sleep_type_b)); |
| } |
| ZxSystemPowerctlArgAcpi(const ZxSystemPowerctlArgAcpi&) = delete; |
| ZxSystemPowerctlArgAcpi& operator=(const ZxSystemPowerctlArgAcpi&) = delete; |
| static ZxSystemPowerctlArgAcpi* instance_; |
| }; |
| |
| ZxSystemPowerctlArgAcpi* ZxSystemPowerctlArgAcpi::instance_ = nullptr; |
| |
| const ZxSystemPowerctlArgAcpi* ZxSystemPowerctlArgAcpi::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxSystemPowerctlArgAcpi; |
| } |
| return instance_; |
| } |
| |
| class ZxSystemPowerctlArgX86PowerLimit : public Class<zx_system_powerctl_arg_t> { |
| public: |
| static const ZxSystemPowerctlArgX86PowerLimit* GetClass(); |
| |
| static uint32_t power_limit(const zx_system_powerctl_arg_t* from) { |
| return from->x86_power_limit.power_limit; |
| } |
| static uint32_t time_window(const zx_system_powerctl_arg_t* from) { |
| return from->x86_power_limit.time_window; |
| } |
| static uint8_t clamp(const zx_system_powerctl_arg_t* from) { return from->x86_power_limit.clamp; } |
| static uint8_t enable(const zx_system_powerctl_arg_t* from) { |
| return from->x86_power_limit.enable; |
| } |
| |
| private: |
| ZxSystemPowerctlArgX86PowerLimit() : Class("zx_system_powerctl_arg_t") { |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint32_t>>( |
| "power_limit", SyscallType::kUint32, power_limit)); |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint32_t>>( |
| "time_window", SyscallType::kUint32, time_window)); |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint8_t>>( |
| "clamp", SyscallType::kUint8, clamp)); |
| AddField(std::make_unique<ClassField<zx_system_powerctl_arg_t, uint8_t>>( |
| "enable", SyscallType::kUint8, enable)); |
| } |
| ZxSystemPowerctlArgX86PowerLimit(const ZxSystemPowerctlArgX86PowerLimit&) = delete; |
| ZxSystemPowerctlArgX86PowerLimit& operator=(const ZxSystemPowerctlArgX86PowerLimit&) = delete; |
| static ZxSystemPowerctlArgX86PowerLimit* instance_; |
| }; |
| |
| ZxSystemPowerctlArgX86PowerLimit* ZxSystemPowerctlArgX86PowerLimit::instance_ = nullptr; |
| |
| const ZxSystemPowerctlArgX86PowerLimit* ZxSystemPowerctlArgX86PowerLimit::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxSystemPowerctlArgX86PowerLimit; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateDebugRegsAArch64Bp : public Class<zx_thread_state_debug_regs_aarch64_bp_t> { |
| public: |
| static const ZxThreadStateDebugRegsAArch64Bp* GetClass(); |
| |
| static uint32_t dbgbcr(const zx_thread_state_debug_regs_aarch64_bp_t* from) { |
| return from->dbgbcr; |
| } |
| static uint64_t dbgbvr(const zx_thread_state_debug_regs_aarch64_bp_t* from) { |
| return from->dbgbvr; |
| } |
| |
| private: |
| ZxThreadStateDebugRegsAArch64Bp() : Class("zx_thread_state_debug_regs_aarch64_bp_t") { |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_bp_t, uint32_t>>( |
| "dbgbcr", SyscallType::kUint32Hexa, dbgbcr)); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_bp_t, uint64_t>>( |
| "dbgbvr", SyscallType::kUint64Hexa, dbgbvr)); |
| } |
| ZxThreadStateDebugRegsAArch64Bp(const ZxThreadStateDebugRegsAArch64Bp&) = delete; |
| ZxThreadStateDebugRegsAArch64Bp& operator=(const ZxThreadStateDebugRegsAArch64Bp&) = delete; |
| static ZxThreadStateDebugRegsAArch64Bp* instance_; |
| }; |
| |
| ZxThreadStateDebugRegsAArch64Bp* ZxThreadStateDebugRegsAArch64Bp::instance_ = nullptr; |
| |
| const ZxThreadStateDebugRegsAArch64Bp* ZxThreadStateDebugRegsAArch64Bp::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateDebugRegsAArch64Bp; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateDebugRegsAArch64Wp : public Class<zx_thread_state_debug_regs_aarch64_wp_t> { |
| public: |
| static const ZxThreadStateDebugRegsAArch64Wp* GetClass(); |
| |
| static uint32_t dbgwcr(const zx_thread_state_debug_regs_aarch64_wp_t* from) { |
| return from->dbgwcr; |
| } |
| static uint64_t dbgwvr(const zx_thread_state_debug_regs_aarch64_wp_t* from) { |
| return from->dbgwvr; |
| } |
| |
| private: |
| ZxThreadStateDebugRegsAArch64Wp() : Class("zx_thread_state_debug_regs_aarch64_wp_t") { |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_wp_t, uint32_t>>( |
| "dbgwcr", SyscallType::kUint32Hexa, dbgwcr)); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_wp_t, uint64_t>>( |
| "dbgwvr", SyscallType::kUint64Hexa, dbgwvr)); |
| } |
| ZxThreadStateDebugRegsAArch64Wp(const ZxThreadStateDebugRegsAArch64Wp&) = delete; |
| ZxThreadStateDebugRegsAArch64Wp& operator=(const ZxThreadStateDebugRegsAArch64Wp&) = delete; |
| static ZxThreadStateDebugRegsAArch64Wp* instance_; |
| }; |
| |
| ZxThreadStateDebugRegsAArch64Wp* ZxThreadStateDebugRegsAArch64Wp::instance_ = nullptr; |
| |
| const ZxThreadStateDebugRegsAArch64Wp* ZxThreadStateDebugRegsAArch64Wp::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateDebugRegsAArch64Wp; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateDebugRegsAArch64 : public Class<zx_thread_state_debug_regs_aarch64_t> { |
| public: |
| static const ZxThreadStateDebugRegsAArch64* GetClass(); |
| |
| static std::pair<const zx_thread_state_debug_regs_aarch64_bp_t*, int> hw_bps( |
| const zx_thread_state_debug_regs_aarch64_t* from) { |
| return std::make_pair( |
| reinterpret_cast<const zx_thread_state_debug_regs_aarch64_bp_t*>(from->hw_bps), |
| sizeof(from->hw_bps) / sizeof(from->hw_bps[0])); |
| } |
| static uint8_t hw_bps_count(const zx_thread_state_debug_regs_aarch64_t* from) { |
| return from->hw_bps_count; |
| } |
| static std::pair<const zx_thread_state_debug_regs_aarch64_wp_t*, int> hw_wps( |
| const zx_thread_state_debug_regs_aarch64_t* from) { |
| return std::make_pair( |
| reinterpret_cast<const zx_thread_state_debug_regs_aarch64_wp_t*>(from->hw_wps), |
| sizeof(from->hw_wps) / sizeof(from->hw_wps[0])); |
| } |
| static uint8_t hw_wps_count(const zx_thread_state_debug_regs_aarch64_t* from) { |
| return from->hw_wps_count; |
| } |
| static uint32_t esr(const zx_thread_state_debug_regs_aarch64_t* from) { return from->esr; } |
| |
| private: |
| ZxThreadStateDebugRegsAArch64() : Class("zx_thread_state_debug_regs_aarch64_t") { |
| AddField(std::make_unique<ArrayClassField<zx_thread_state_debug_regs_aarch64_t, |
| zx_thread_state_debug_regs_aarch64_bp_t>>( |
| "hw_bps", hw_bps, ZxThreadStateDebugRegsAArch64Bp::GetClass())); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_t, uint8_t>>( |
| "hw_bps_count", SyscallType::kUint8Hexa, hw_bps_count)); |
| AddField(std::make_unique<ArrayClassField<zx_thread_state_debug_regs_aarch64_t, |
| zx_thread_state_debug_regs_aarch64_wp_t>>( |
| "hw_wps", hw_wps, ZxThreadStateDebugRegsAArch64Wp::GetClass())); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_t, uint8_t>>( |
| "hw_wps_count", SyscallType::kUint8Hexa, hw_wps_count)); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_aarch64_t, uint32_t>>( |
| "esr", SyscallType::kUint32Hexa, esr)); |
| } |
| ZxThreadStateDebugRegsAArch64(const ZxThreadStateDebugRegsAArch64&) = delete; |
| ZxThreadStateDebugRegsAArch64& operator=(const ZxThreadStateDebugRegsAArch64&) = delete; |
| static ZxThreadStateDebugRegsAArch64* instance_; |
| }; |
| |
| ZxThreadStateDebugRegsAArch64* ZxThreadStateDebugRegsAArch64::instance_ = nullptr; |
| |
| const ZxThreadStateDebugRegsAArch64* ZxThreadStateDebugRegsAArch64::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateDebugRegsAArch64; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateDebugRegsX86 : public Class<zx_thread_state_debug_regs_x86_t> { |
| public: |
| static const ZxThreadStateDebugRegsX86* GetClass(); |
| |
| static std::pair<const uint64_t*, int> dr(const zx_thread_state_debug_regs_x86_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->dr), |
| sizeof(from->dr) / sizeof(uint64_t)); |
| } |
| static uint64_t dr6(const zx_thread_state_debug_regs_x86_t* from) { return from->dr6; } |
| static uint64_t dr7(const zx_thread_state_debug_regs_x86_t* from) { return from->dr7; } |
| |
| private: |
| ZxThreadStateDebugRegsX86() : Class("zx_thread_state_debug_regs_x86_t") { |
| AddField(std::make_unique<DynamicArrayField<zx_thread_state_debug_regs_x86_t, uint64_t, int>>( |
| "dr", SyscallType::kUint64Hexa, dr)); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_x86_t, uint64_t>>( |
| "dr6", SyscallType::kUint64Hexa, dr6)); |
| AddField(std::make_unique<ClassField<zx_thread_state_debug_regs_x86_t, uint64_t>>( |
| "dr7", SyscallType::kUint64Hexa, dr7)); |
| } |
| ZxThreadStateDebugRegsX86(const ZxThreadStateDebugRegsX86&) = delete; |
| ZxThreadStateDebugRegsX86& operator=(const ZxThreadStateDebugRegsX86&) = delete; |
| static ZxThreadStateDebugRegsX86* instance_; |
| }; |
| |
| ZxThreadStateDebugRegsX86* ZxThreadStateDebugRegsX86::instance_ = nullptr; |
| |
| const ZxThreadStateDebugRegsX86* ZxThreadStateDebugRegsX86::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateDebugRegsX86; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateGeneralRegsAArch64 : public Class<zx_thread_state_general_regs_aarch64_t> { |
| public: |
| static const ZxThreadStateGeneralRegsAArch64* GetClass(); |
| |
| static std::pair<const uint64_t*, int> r(const zx_thread_state_general_regs_aarch64_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->r), |
| sizeof(from->r) / sizeof(uint64_t)); |
| } |
| static uint64_t lr(const zx_thread_state_general_regs_aarch64_t* from) { return from->lr; } |
| static uint64_t sp(const zx_thread_state_general_regs_aarch64_t* from) { return from->sp; } |
| static uint64_t pc(const zx_thread_state_general_regs_aarch64_t* from) { return from->pc; } |
| static uint64_t cpsr(const zx_thread_state_general_regs_aarch64_t* from) { return from->cpsr; } |
| static uint64_t tpidr(const zx_thread_state_general_regs_aarch64_t* from) { return from->tpidr; } |
| |
| private: |
| ZxThreadStateGeneralRegsAArch64() : Class("zx_thread_state_general_regs_aarch64_t") { |
| AddField( |
| std::make_unique<DynamicArrayField<zx_thread_state_general_regs_aarch64_t, uint64_t, int>>( |
| "r", SyscallType::kUint64Hexa, r)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_aarch64_t, uint64_t>>( |
| "lr", SyscallType::kUint64Hexa, lr)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_aarch64_t, uint64_t>>( |
| "sp", SyscallType::kUint64Hexa, sp)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_aarch64_t, uint64_t>>( |
| "pc", SyscallType::kUint64Hexa, pc)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_aarch64_t, uint64_t>>( |
| "cpsr", SyscallType::kUint64Hexa, cpsr)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_aarch64_t, uint64_t>>( |
| "tpidr", SyscallType::kUint64Hexa, tpidr)); |
| } |
| ZxThreadStateGeneralRegsAArch64(const ZxThreadStateGeneralRegsAArch64&) = delete; |
| ZxThreadStateGeneralRegsAArch64& operator=(const ZxThreadStateGeneralRegsAArch64&) = delete; |
| static ZxThreadStateGeneralRegsAArch64* instance_; |
| }; |
| |
| ZxThreadStateGeneralRegsAArch64* ZxThreadStateGeneralRegsAArch64::instance_ = nullptr; |
| |
| const ZxThreadStateGeneralRegsAArch64* ZxThreadStateGeneralRegsAArch64::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateGeneralRegsAArch64; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateGeneralRegsX86 : public Class<zx_thread_state_general_regs_x86_t> { |
| public: |
| static const ZxThreadStateGeneralRegsX86* GetClass(); |
| |
| static uint64_t rax(const zx_thread_state_general_regs_x86_t* from) { return from->rax; } |
| static uint64_t rbx(const zx_thread_state_general_regs_x86_t* from) { return from->rbx; } |
| static uint64_t rcx(const zx_thread_state_general_regs_x86_t* from) { return from->rcx; } |
| static uint64_t rdx(const zx_thread_state_general_regs_x86_t* from) { return from->rdx; } |
| static uint64_t rsi(const zx_thread_state_general_regs_x86_t* from) { return from->rsi; } |
| static uint64_t rdi(const zx_thread_state_general_regs_x86_t* from) { return from->rdi; } |
| static uint64_t rbp(const zx_thread_state_general_regs_x86_t* from) { return from->rbp; } |
| static uint64_t rsp(const zx_thread_state_general_regs_x86_t* from) { return from->rsp; } |
| static uint64_t r8(const zx_thread_state_general_regs_x86_t* from) { return from->r8; } |
| static uint64_t r9(const zx_thread_state_general_regs_x86_t* from) { return from->r9; } |
| static uint64_t r10(const zx_thread_state_general_regs_x86_t* from) { return from->r10; } |
| static uint64_t r11(const zx_thread_state_general_regs_x86_t* from) { return from->r11; } |
| static uint64_t r12(const zx_thread_state_general_regs_x86_t* from) { return from->r12; } |
| static uint64_t r13(const zx_thread_state_general_regs_x86_t* from) { return from->r13; } |
| static uint64_t r14(const zx_thread_state_general_regs_x86_t* from) { return from->r14; } |
| static uint64_t r15(const zx_thread_state_general_regs_x86_t* from) { return from->r15; } |
| static uint64_t rip(const zx_thread_state_general_regs_x86_t* from) { return from->rip; } |
| static uint64_t rflags(const zx_thread_state_general_regs_x86_t* from) { return from->rflags; } |
| static uint64_t fs_base(const zx_thread_state_general_regs_x86_t* from) { return from->fs_base; } |
| static uint64_t gs_base(const zx_thread_state_general_regs_x86_t* from) { return from->gs_base; } |
| |
| private: |
| ZxThreadStateGeneralRegsX86() : Class("zx_thread_state_general_regs_x86_t") { |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rax", SyscallType::kUint64Hexa, rax)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rbx", SyscallType::kUint64Hexa, rbx)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rcx", SyscallType::kUint64Hexa, rcx)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rdx", SyscallType::kUint64Hexa, rdx)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rsi", SyscallType::kUint64Hexa, rsi)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rdi", SyscallType::kUint64Hexa, rdi)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rbp", SyscallType::kUint64Hexa, rbp)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rsp", SyscallType::kUint64Hexa, rsp)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r8", SyscallType::kUint64Hexa, r8)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r9", SyscallType::kUint64Hexa, r9)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r10", SyscallType::kUint64Hexa, r10)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r11", SyscallType::kUint64Hexa, r11)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r12", SyscallType::kUint64Hexa, r12)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r13", SyscallType::kUint64Hexa, r13)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r14", SyscallType::kUint64Hexa, r14)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "r15", SyscallType::kUint64Hexa, r15)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rip", SyscallType::kUint64Hexa, rip)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "rflags", SyscallType::kUint64Hexa, rflags)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "fs_base", SyscallType::kUint64Hexa, fs_base)); |
| AddField(std::make_unique<ClassField<zx_thread_state_general_regs_x86_t, uint64_t>>( |
| "gs_base", SyscallType::kUint64Hexa, gs_base)); |
| } |
| ZxThreadStateGeneralRegsX86(const ZxThreadStateGeneralRegsX86&) = delete; |
| ZxThreadStateGeneralRegsX86& operator=(const ZxThreadStateGeneralRegsX86&) = delete; |
| static ZxThreadStateGeneralRegsX86* instance_; |
| }; |
| |
| ZxThreadStateGeneralRegsX86* ZxThreadStateGeneralRegsX86::instance_ = nullptr; |
| |
| const ZxThreadStateGeneralRegsX86* ZxThreadStateGeneralRegsX86::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateGeneralRegsX86; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateFpRegsX86 : public Class<zx_thread_state_fp_regs_x86_t> { |
| public: |
| static const ZxThreadStateFpRegsX86* GetClass(); |
| |
| static uint16_t fcw(const zx_thread_state_fp_regs_x86_t* from) { return from->fcw; } |
| static uint16_t fsw(const zx_thread_state_fp_regs_x86_t* from) { return from->fsw; } |
| static uint8_t ftw(const zx_thread_state_fp_regs_x86_t* from) { return from->ftw; } |
| static uint16_t fop(const zx_thread_state_fp_regs_x86_t* from) { return from->fop; } |
| static uint64_t fip(const zx_thread_state_fp_regs_x86_t* from) { return from->fip; } |
| static uint64_t fdp(const zx_thread_state_fp_regs_x86_t* from) { return from->fdp; } |
| static std::pair<const zx_uint128_t*, int> st(const zx_thread_state_fp_regs_x86_t* from) { |
| return std::make_pair(reinterpret_cast<const zx_uint128_t*>(from->st), |
| sizeof(from->st) / sizeof(from->st[0])); |
| } |
| |
| private: |
| ZxThreadStateFpRegsX86() : Class("zx_thread_state_fp_regs_x86_t") { |
| AddField(std::make_unique<ClassField<zx_thread_state_fp_regs_x86_t, uint16_t>>( |
| "fcw", SyscallType::kUint16Hexa, fcw)); |
| AddField(std::make_unique<ClassField<zx_thread_state_fp_regs_x86_t, uint16_t>>( |
| "fsw", SyscallType::kUint16Hexa, fsw)); |
| AddField(std::make_unique<ClassField<zx_thread_state_fp_regs_x86_t, uint8_t>>( |
| "ftw", SyscallType::kUint8Hexa, ftw)); |
| AddField(std::make_unique<ClassField<zx_thread_state_fp_regs_x86_t, uint16_t>>( |
| "fop", SyscallType::kUint16Hexa, fop)); |
| AddField(std::make_unique<ClassField<zx_thread_state_fp_regs_x86_t, uint64_t>>( |
| "fip", SyscallType::kUint64Hexa, fip)); |
| AddField(std::make_unique<ClassField<zx_thread_state_fp_regs_x86_t, uint64_t>>( |
| "fdp", SyscallType::kUint64Hexa, fdp)); |
| AddField(std::make_unique<DynamicArrayField<zx_thread_state_fp_regs_x86_t, zx_uint128_t, int>>( |
| "st", SyscallType::kUint128Hexa, st)); |
| } |
| ZxThreadStateFpRegsX86(const ZxThreadStateFpRegsX86&) = delete; |
| ZxThreadStateFpRegsX86& operator=(const ZxThreadStateFpRegsX86&) = delete; |
| static ZxThreadStateFpRegsX86* instance_; |
| }; |
| |
| ZxThreadStateFpRegsX86* ZxThreadStateFpRegsX86::instance_ = nullptr; |
| |
| const ZxThreadStateFpRegsX86* ZxThreadStateFpRegsX86::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateFpRegsX86; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateVectorRegsAArch64 : public Class<zx_thread_state_vector_regs_aarch64_t> { |
| public: |
| static const ZxThreadStateVectorRegsAArch64* GetClass(); |
| |
| static uint32_t fpcr(const zx_thread_state_vector_regs_aarch64_t* from) { return from->fpcr; } |
| static uint32_t fpsr(const zx_thread_state_vector_regs_aarch64_t* from) { return from->fpsr; } |
| static std::pair<const zx_uint128_t*, int> v(const zx_thread_state_vector_regs_aarch64_t* from) { |
| return std::make_pair(reinterpret_cast<const zx_uint128_t*>(from->v), |
| sizeof(from->v) / sizeof(from->v[0])); |
| } |
| |
| private: |
| ZxThreadStateVectorRegsAArch64() : Class("zx_thread_state_vector_regs_aarch64_t") { |
| AddField(std::make_unique<ClassField<zx_thread_state_vector_regs_aarch64_t, uint32_t>>( |
| "fpcr", SyscallType::kUint32Hexa, fpcr)); |
| AddField(std::make_unique<ClassField<zx_thread_state_vector_regs_aarch64_t, uint32_t>>( |
| "fpsr", SyscallType::kUint32Hexa, fpsr)); |
| AddField(std::make_unique< |
| DynamicArrayField<zx_thread_state_vector_regs_aarch64_t, zx_uint128_t, int>>( |
| "v", SyscallType::kUint128Hexa, v)); |
| } |
| ZxThreadStateVectorRegsAArch64(const ZxThreadStateVectorRegsAArch64&) = delete; |
| ZxThreadStateVectorRegsAArch64& operator=(const ZxThreadStateVectorRegsAArch64&) = delete; |
| static ZxThreadStateVectorRegsAArch64* instance_; |
| }; |
| |
| ZxThreadStateVectorRegsAArch64* ZxThreadStateVectorRegsAArch64::instance_ = nullptr; |
| |
| const ZxThreadStateVectorRegsAArch64* ZxThreadStateVectorRegsAArch64::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateVectorRegsAArch64; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateVectorRegsX86Zmm : public Class<zx_thread_state_vector_regs_x86_zmm_t> { |
| public: |
| static const ZxThreadStateVectorRegsX86Zmm* GetClass(); |
| |
| static std::pair<const uint64_t*, int> v(const zx_thread_state_vector_regs_x86_zmm_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->v), |
| sizeof(from->v) / sizeof(from->v[0])); |
| } |
| |
| private: |
| ZxThreadStateVectorRegsX86Zmm() : Class("zx_thread_state_vector_regs_x86_zmm_t") { |
| AddField( |
| std::make_unique<DynamicArrayField<zx_thread_state_vector_regs_x86_zmm_t, uint64_t, int>>( |
| "v", SyscallType::kUint64Hexa, v)); |
| } |
| ZxThreadStateVectorRegsX86Zmm(const ZxThreadStateVectorRegsX86Zmm&) = delete; |
| ZxThreadStateVectorRegsX86Zmm& operator=(const ZxThreadStateVectorRegsX86Zmm&) = delete; |
| static ZxThreadStateVectorRegsX86Zmm* instance_; |
| }; |
| |
| ZxThreadStateVectorRegsX86Zmm* ZxThreadStateVectorRegsX86Zmm::instance_ = nullptr; |
| |
| const ZxThreadStateVectorRegsX86Zmm* ZxThreadStateVectorRegsX86Zmm::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateVectorRegsX86Zmm; |
| } |
| return instance_; |
| } |
| |
| class ZxThreadStateVectorRegsX86 : public Class<zx_thread_state_vector_regs_x86_t> { |
| public: |
| static const ZxThreadStateVectorRegsX86* GetClass(); |
| |
| static std::pair<const zx_thread_state_vector_regs_x86_zmm_t*, int> zmm( |
| const zx_thread_state_vector_regs_x86_t* from) { |
| return std::make_pair(reinterpret_cast<const zx_thread_state_vector_regs_x86_zmm_t*>(from->zmm), |
| sizeof(from->zmm) / sizeof(from->zmm[0])); |
| } |
| static std::pair<const uint64_t*, int> opmask(const zx_thread_state_vector_regs_x86_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->opmask), |
| sizeof(from->opmask) / sizeof(from->opmask[0])); |
| } |
| static uint32_t mxcsr(const zx_thread_state_vector_regs_x86_t* from) { return from->mxcsr; } |
| |
| private: |
| ZxThreadStateVectorRegsX86() : Class("zx_thread_state_vector_regs_x86_t") { |
| AddField(std::make_unique<ArrayClassField<zx_thread_state_vector_regs_x86_t, |
| zx_thread_state_vector_regs_x86_zmm_t>>( |
| "zmm", zmm, ZxThreadStateVectorRegsX86Zmm::GetClass())); |
| AddField(std::make_unique<DynamicArrayField<zx_thread_state_vector_regs_x86_t, uint64_t, int>>( |
| "opmask", SyscallType::kUint64Hexa, opmask)); |
| AddField(std::make_unique<ClassField<zx_thread_state_vector_regs_x86_t, uint32_t>>( |
| "mxcsr", SyscallType::kUint32Hexa, mxcsr)); |
| } |
| ZxThreadStateVectorRegsX86(const ZxThreadStateVectorRegsX86&) = delete; |
| ZxThreadStateVectorRegsX86& operator=(const ZxThreadStateVectorRegsX86&) = delete; |
| static ZxThreadStateVectorRegsX86* instance_; |
| }; |
| |
| ZxThreadStateVectorRegsX86* ZxThreadStateVectorRegsX86::instance_ = nullptr; |
| |
| const ZxThreadStateVectorRegsX86* ZxThreadStateVectorRegsX86::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxThreadStateVectorRegsX86; |
| } |
| return instance_; |
| } |
| |
| class ZxVcpuIo : public Class<zx_vcpu_io_t> { |
| public: |
| static const ZxVcpuIo* GetClass(); |
| |
| static uint8_t access_size(const zx_vcpu_io_t* from) { return from->access_size; } |
| static uint8_t u8(const zx_vcpu_io_t* from) { return from->u8; } |
| static uint16_t u16(const zx_vcpu_io_t* from) { return from->u16; } |
| static uint32_t u32(const zx_vcpu_io_t* from) { return from->u32; } |
| static std::pair<const uint8_t*, int> data(const zx_vcpu_io_t* from) { |
| return std::make_pair(reinterpret_cast<const uint8_t*>(from->data), |
| sizeof(from->data) / sizeof(uint8_t)); |
| } |
| |
| private: |
| ZxVcpuIo() : Class("zx_vcpu_io_t") { |
| AddField(std::make_unique<ClassField<zx_vcpu_io_t, uint8_t>>("access_size", SyscallType::kUint8, |
| access_size)); |
| AddField( |
| std::make_unique<ClassField<zx_vcpu_io_t, uint8_t>>("u8", SyscallType::kUint8Hexa, u8)); |
| AddField( |
| std::make_unique<ClassField<zx_vcpu_io_t, uint16_t>>("u16", SyscallType::kUint16Hexa, u16)); |
| AddField( |
| std::make_unique<ClassField<zx_vcpu_io_t, uint32_t>>("u32", SyscallType::kUint32Hexa, u32)); |
| AddField(std::make_unique<DynamicArrayField<zx_vcpu_io_t, uint8_t, int>>( |
| "data", SyscallType::kUint8Hexa, data)); |
| } |
| ZxVcpuIo(const ZxVcpuIo&) = delete; |
| ZxVcpuIo& operator=(const ZxVcpuIo&) = delete; |
| static ZxVcpuIo* instance_; |
| }; |
| |
| ZxVcpuIo* ZxVcpuIo::instance_ = nullptr; |
| |
| const ZxVcpuIo* ZxVcpuIo::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxVcpuIo; |
| } |
| return instance_; |
| } |
| |
| class ZxVcpuStateAArch64 : public Class<zx_vcpu_state_aarch64_t> { |
| public: |
| static const ZxVcpuStateAArch64* GetClass(); |
| |
| static std::pair<const uint64_t*, int> x(const zx_vcpu_state_aarch64_t* from) { |
| return std::make_pair(reinterpret_cast<const uint64_t*>(from->x), |
| sizeof(from->x) / sizeof(uint64_t)); |
| } |
| static uint64_t sp(const zx_vcpu_state_aarch64_t* from) { return from->sp; } |
| static uint32_t cpsr(const zx_vcpu_state_aarch64_t* from) { return from->cpsr; } |
| |
| private: |
| ZxVcpuStateAArch64() : Class("zx_vcpu_state_aarch64_t") { |
| AddField(std::make_unique<DynamicArrayField<zx_vcpu_state_aarch64_t, uint64_t, int>>( |
| "x", SyscallType::kUint64Hexa, x)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_aarch64_t, uint64_t>>( |
| "sp", SyscallType::kUint64Hexa, sp)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_aarch64_t, uint32_t>>( |
| "cpsr", SyscallType::kUint32Hexa, cpsr)); |
| } |
| ZxVcpuStateAArch64(const ZxVcpuStateAArch64&) = delete; |
| ZxVcpuStateAArch64& operator=(const ZxVcpuStateAArch64&) = delete; |
| static ZxVcpuStateAArch64* instance_; |
| }; |
| |
| ZxVcpuStateAArch64* ZxVcpuStateAArch64::instance_ = nullptr; |
| |
| const ZxVcpuStateAArch64* ZxVcpuStateAArch64::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxVcpuStateAArch64; |
| } |
| return instance_; |
| } |
| |
| class ZxVcpuStateX86 : public Class<zx_vcpu_state_x86_t> { |
| public: |
| static const ZxVcpuStateX86* GetClass(); |
| |
| static uint64_t rax(const zx_vcpu_state_x86_t* from) { return from->rax; } |
| static uint64_t rcx(const zx_vcpu_state_x86_t* from) { return from->rcx; } |
| static uint64_t rdx(const zx_vcpu_state_x86_t* from) { return from->rdx; } |
| static uint64_t rbx(const zx_vcpu_state_x86_t* from) { return from->rbx; } |
| static uint64_t rsp(const zx_vcpu_state_x86_t* from) { return from->rsp; } |
| static uint64_t rbp(const zx_vcpu_state_x86_t* from) { return from->rbp; } |
| static uint64_t rsi(const zx_vcpu_state_x86_t* from) { return from->rsi; } |
| static uint64_t rdi(const zx_vcpu_state_x86_t* from) { return from->rdi; } |
| static uint64_t r8(const zx_vcpu_state_x86_t* from) { return from->r8; } |
| static uint64_t r9(const zx_vcpu_state_x86_t* from) { return from->r9; } |
| static uint64_t r10(const zx_vcpu_state_x86_t* from) { return from->r10; } |
| static uint64_t r11(const zx_vcpu_state_x86_t* from) { return from->r11; } |
| static uint64_t r12(const zx_vcpu_state_x86_t* from) { return from->r12; } |
| static uint64_t r13(const zx_vcpu_state_x86_t* from) { return from->r13; } |
| static uint64_t r14(const zx_vcpu_state_x86_t* from) { return from->r14; } |
| static uint64_t r15(const zx_vcpu_state_x86_t* from) { return from->r15; } |
| static uint64_t rflags(const zx_vcpu_state_x86_t* from) { return from->rflags; } |
| |
| private: |
| ZxVcpuStateX86() : Class("zx_vcpu_state_x86_t") { |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rax", SyscallType::kUint64Hexa, rax)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rcx", SyscallType::kUint64Hexa, rcx)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rdx", SyscallType::kUint64Hexa, rdx)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rbx", SyscallType::kUint64Hexa, rbx)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rsp", SyscallType::kUint64Hexa, rsp)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rbp", SyscallType::kUint64Hexa, rbp)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rsi", SyscallType::kUint64Hexa, rsi)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rdi", SyscallType::kUint64Hexa, rdi)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r8", SyscallType::kUint64Hexa, r8)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r9", SyscallType::kUint64Hexa, r9)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r10", SyscallType::kUint64Hexa, r10)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r11", SyscallType::kUint64Hexa, r11)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r12", SyscallType::kUint64Hexa, r12)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r13", SyscallType::kUint64Hexa, r13)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r14", SyscallType::kUint64Hexa, r14)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "r15", SyscallType::kUint64Hexa, r15)); |
| AddField(std::make_unique<ClassField<zx_vcpu_state_x86_t, uint64_t>>( |
| "rflags", SyscallType::kUint64Hexa, rflags)); |
| } |
| ZxVcpuStateX86(const ZxVcpuStateX86&) = delete; |
| ZxVcpuStateX86& operator=(const ZxVcpuStateX86&) = delete; |
| static ZxVcpuStateX86* instance_; |
| }; |
| |
| ZxVcpuStateX86* ZxVcpuStateX86::instance_ = nullptr; |
| |
| const ZxVcpuStateX86* ZxVcpuStateX86::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxVcpuStateX86; |
| } |
| return instance_; |
| } |
| |
| class ZxWaitItem : public Class<zx_wait_item_t> { |
| public: |
| static const ZxWaitItem* GetClass(); |
| |
| static zx_handle_t handle(const zx_wait_item_t* from) { return from->handle; } |
| static zx_signals_t waitfor(const zx_wait_item_t* from) { return from->waitfor; } |
| static zx_signals_t pending(const zx_wait_item_t* from) { return from->pending; } |
| |
| private: |
| ZxWaitItem() : Class("zx_wait_item_t") { |
| AddField(std::make_unique<ClassField<zx_wait_item_t, zx_handle_t>>( |
| "handle", SyscallType::kHandle, handle)); |
| AddField(std::make_unique<ClassField<zx_wait_item_t, zx_signals_t>>( |
| "waitfor", SyscallType::kSignals, waitfor)); |
| AddField(std::make_unique<ClassField<zx_wait_item_t, zx_signals_t>>( |
| "pending", SyscallType::kSignals, pending)); |
| } |
| ZxWaitItem(const ZxWaitItem&) = delete; |
| ZxWaitItem& operator=(const ZxWaitItem&) = delete; |
| static ZxWaitItem* instance_; |
| }; |
| |
| ZxWaitItem* ZxWaitItem::instance_ = nullptr; |
| |
| const ZxWaitItem* ZxWaitItem::GetClass() { |
| if (instance_ == nullptr) { |
| instance_ = new ZxWaitItem; |
| } |
| return instance_; |
| } |
| |
| void SyscallDecoderDispatcher::Populate() { |
| { |
| Syscall* extract_handles = |
| AddFunction("processargs_extract_handles", SyscallReturnType::kNoReturn); |
| // Arguments |
| auto nhandles = extract_handles->Argument<uint32_t>(SyscallType::kUint32); |
| auto handles = extract_handles->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto handle_info = extract_handles->PointerArgument<uint32_t>(SyscallType::kUint32Hexa); |
| // Inputs |
| extract_handles->InputBuffer<zx_handle_t, zx_handle_t, uint32_t>( |
| "handles", SyscallType::kHandle, std::make_unique<ArgumentAccess<zx_handle_t>>(handles), |
| std::make_unique<ArgumentAccess<uint32_t>>(nhandles)); |
| extract_handles->InputBuffer<uint32_t, uint32_t, uint32_t>( |
| "handles", SyscallType::kUint32Hexa, |
| std::make_unique<ArgumentAccess<uint32_t>>(handle_info), |
| std::make_unique<ArgumentAccess<uint32_t>>(nhandles)); |
| extract_handles->set_inputs_decoded_action(&SyscallDecoderDispatcher::ExtractHandleInfos); |
| } |
| |
| { |
| Syscall* libc_extensions_init = |
| AddFunction("__libc_extensions_init", SyscallReturnType::kNoReturn); |
| // Arguments |
| auto handle_count = libc_extensions_init->Argument<uint32_t>(SyscallType::kUint32); |
| auto handle = libc_extensions_init->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto handle_info = libc_extensions_init->PointerArgument<uint32_t>(SyscallType::kUint32Hexa); |
| auto name_count = libc_extensions_init->Argument<uint32_t>(SyscallType::kUint32); |
| auto names = libc_extensions_init->PointerArgument<char*>(SyscallType::kChar); |
| // Inputs |
| libc_extensions_init->Input<uint32_t>("handle_count", |
| std::make_unique<ArgumentAccess<uint32_t>>(handle_count)); |
| libc_extensions_init->InputBuffer<zx_handle_t, zx_handle_t, uint32_t>( |
| "handle", SyscallType::kHandle, std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(handle_count)); |
| libc_extensions_init->InputBuffer<uint32_t, uint32_t, uint32_t>( |
| "handle_info", SyscallType::kUint32Hexa, |
| std::make_unique<ArgumentAccess<uint32_t>>(handle_info), |
| std::make_unique<ArgumentAccess<uint32_t>>(handle_count)); |
| libc_extensions_init->Input<uint32_t>("name_count", |
| std::make_unique<ArgumentAccess<uint32_t>>(name_count)); |
| libc_extensions_init->InputStringBuffer("names", std::make_unique<ArgumentAccess<char*>>(names), |
| std::make_unique<ArgumentAccess<uint32_t>>(name_count), |
| 80); |
| libc_extensions_init->set_inputs_decoded_action(&SyscallDecoderDispatcher::LibcExtensionsInit); |
| } |
| |
| { |
| Syscall* zx_clock_get = Add("zx_clock_get", SyscallReturnType::kStatus); |
| // Arguments |
| auto clock_id = zx_clock_get->Argument<zx_clock_t>(SyscallType::kClock); |
| auto out = zx_clock_get->PointerArgument<zx_time_t>(SyscallType::kTime); |
| // Inputs |
| zx_clock_get->Input<zx_clock_t>("clock_id", |
| std::make_unique<ArgumentAccess<zx_clock_t>>(clock_id)); |
| // Outputs |
| zx_clock_get->Output<zx_time_t>(ZX_OK, "out", std::make_unique<ArgumentAccess<zx_time_t>>(out)); |
| } |
| |
| { Add("zx_clock_get_monotonic", SyscallReturnType::kTime); } |
| |
| { |
| Syscall* zx_nanosleep = Add("zx_nanosleep", SyscallReturnType::kStatus); |
| // Arguments |
| auto deadline = zx_nanosleep->Argument<zx_time_t>(SyscallType::kTime); |
| // Inputs |
| zx_nanosleep->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| } |
| |
| { Add("zx_ticks_get", SyscallReturnType::kTicks); } |
| |
| { Add("zx_ticks_per_second", SyscallReturnType::kTicks); } |
| |
| { |
| Syscall* zx_deadline_after = Add("zx_deadline_after", SyscallReturnType::kTime); |
| // Arguments |
| auto nanoseconds = zx_deadline_after->Argument<zx_duration_t>(SyscallType::kDuration); |
| // Inputs |
| zx_deadline_after->Input<zx_duration_t>( |
| "nanoseconds", std::make_unique<ArgumentAccess<zx_duration_t>>(nanoseconds)); |
| } |
| |
| { |
| Syscall* zx_clock_adjust = Add("zx_clock_adjust", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_clock_adjust->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto clock_id = zx_clock_adjust->Argument<zx_clock_t>(SyscallType::kClock); |
| auto offset = zx_clock_adjust->Argument<int64_t>(SyscallType::kInt64); |
| // Inputs |
| zx_clock_adjust->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_clock_adjust->Input<zx_clock_t>("clock_id", |
| std::make_unique<ArgumentAccess<zx_clock_t>>(clock_id)); |
| zx_clock_adjust->Input<int64_t>("offset", std::make_unique<ArgumentAccess<int64_t>>(offset)); |
| } |
| |
| { Add("zx_system_get_dcache_line_size", SyscallReturnType::kUint32); } |
| |
| { Add("zx_system_get_num_cpus", SyscallReturnType::kUint32); } |
| |
| { Add("zx_system_get_version_string", SyscallReturnType::kStringView); } |
| |
| { Add("zx_system_get_physmem", SyscallReturnType::kUint64); } |
| |
| { |
| Syscall* zx_system_get_event = Add("zx_system_get_event", SyscallReturnType::kStatus); |
| // Arguments |
| auto root_job = zx_system_get_event->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_system_get_event->Argument<uint32_t>(SyscallType::kSystemEventType); |
| auto event = zx_system_get_event->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_system_get_event->Input<uint32_t>("root_job", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(root_job)); |
| zx_system_get_event->Input<uint32_t>("kind", std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| // Outputs |
| zx_system_get_event->Output<zx_handle_t>(ZX_OK, "event", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(event)); |
| } |
| |
| { |
| Syscall* zx_system_get_features = Add("zx_system_get_features", SyscallReturnType::kStatus); |
| // Arguments |
| auto kind = zx_system_get_features->Argument<uint32_t>(SyscallType::kFeatureKind); |
| auto features = zx_system_get_features->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_system_get_features->Input<uint32_t>("kind", |
| std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| // Outputs |
| zx_system_get_features->Output<uint32_t>(ZX_OK, "features", |
| std::make_unique<ArgumentAccess<uint32_t>>(features)); |
| } |
| |
| { |
| Syscall* zx_system_mexec = Add("zx_system_mexec", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_system_mexec->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kernel_vmo = zx_system_mexec->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto bootimage_vmo = zx_system_mexec->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_system_mexec->Input<uint32_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_system_mexec->Input<uint32_t>("kernel_vmo", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(kernel_vmo)); |
| zx_system_mexec->Input<uint32_t>("bootimage_vmo", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(bootimage_vmo)); |
| } |
| |
| { |
| Syscall* zx_system_mexec_payload_get = |
| Add("zx_system_mexec_payload_get", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_system_mexec_payload_get->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto buffer = zx_system_mexec_payload_get->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto buffer_size = zx_system_mexec_payload_get->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_system_mexec_payload_get->Input<uint32_t>( |
| "resource", std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_system_mexec_payload_get->Input<size_t>( |
| "buffer_size", std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_system_mexec_payload_get->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_system_powerctl = Add("zx_system_powerctl", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_system_powerctl->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto cmd = zx_system_powerctl->Argument<uint32_t>(SyscallType::kSystemPowerctl); |
| auto arg = zx_system_powerctl->PointerArgument<uint8_t>(SyscallType::kUint8); |
| // Conditional field Ids |
| const uint8_t kZxSystemPowerctl_ZX_SYSTEM_POWERCTL_ACPI_TRANSITION_S_STATE = 1; |
| const uint8_t kZxSystemPowerctl_ZX_SYSTEM_POWERCTL_X86_SET_PKG_PL1 = 2; |
| // Inputs |
| zx_system_powerctl->Input<uint32_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_system_powerctl->Input<uint32_t>("cmd", std::make_unique<ArgumentAccess<uint32_t>>(cmd)); |
| zx_system_powerctl |
| ->InputObject<zx_system_powerctl_arg_t>("arg", |
| std::make_unique<ArgumentAccess<uint8_t>>(arg), |
| ZxSystemPowerctlArgAcpi::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(cmd), |
| ZX_SYSTEM_POWERCTL_ACPI_TRANSITION_S_STATE) |
| ->SetId(kZxSystemPowerctl_ZX_SYSTEM_POWERCTL_ACPI_TRANSITION_S_STATE); |
| zx_system_powerctl |
| ->InputObject<zx_system_powerctl_arg_t>("arg", |
| std::make_unique<ArgumentAccess<uint8_t>>(arg), |
| ZxSystemPowerctlArgX86PowerLimit::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(cmd), |
| ZX_SYSTEM_POWERCTL_X86_SET_PKG_PL1) |
| ->SetId(kZxSystemPowerctl_ZX_SYSTEM_POWERCTL_X86_SET_PKG_PL1); |
| } |
| |
| { |
| Syscall* zx_cache_flush = Add("zx_cache_flush", SyscallReturnType::kStatus); |
| // Arguments |
| auto addr = zx_cache_flush->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto size = zx_cache_flush->Argument<size_t>(SyscallType::kSize); |
| auto options = zx_cache_flush->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_cache_flush->Input<zx_vaddr_t>("addr", std::make_unique<ArgumentAccess<zx_vaddr_t>>(addr)); |
| zx_cache_flush->Input<size_t>("size", std::make_unique<ArgumentAccess<size_t>>(size)); |
| zx_cache_flush->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| } |
| |
| { |
| Syscall* zx_handle_close = Add("zx_handle_close", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_handle_close->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_handle_close->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| |
| zx_handle_close->set_compute_statistics([](const OutputEvent* event) { |
| auto handle_info = event->invoked_event()->GetHandleInfo( |
| event->syscall()->SearchInlineMember("handle", /*invoked=*/true)); |
| if (handle_info != nullptr) { |
| handle_info->AddCloseEvent(event); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_handle_close_many = Add("zx_handle_close_many", SyscallReturnType::kStatus); |
| // Arguments |
| auto handles = zx_handle_close_many->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto num_handles = zx_handle_close_many->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_handle_close_many->InputBuffer<zx_handle_t, zx_handle_t, size_t>( |
| "handles", SyscallType::kHandle, std::make_unique<ArgumentAccess<zx_handle_t>>(handles), |
| std::make_unique<ArgumentAccess<size_t>>(num_handles)); |
| |
| zx_handle_close_many->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::Value* values = event->invoked_event()->GetValue( |
| event->syscall()->SearchOutlineMember("handles", /*invoked=*/true)); |
| FX_DCHECK(values != nullptr); |
| auto handles = values->AsVectorValue(); |
| FX_DCHECK(handles != nullptr); |
| for (const auto& value : handles->values()) { |
| auto handle_value = value->AsHandleValue(); |
| FX_DCHECK(handle_value != nullptr); |
| if (handle_value->handle().handle != ZX_HANDLE_INVALID) { |
| HandleInfo* handle_info = |
| event->thread()->process()->SearchHandleInfo(handle_value->handle().handle); |
| handle_info->AddCloseEvent(event); |
| } |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_handle_duplicate = Add("zx_handle_duplicate", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_handle_duplicate->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto rights = zx_handle_duplicate->Argument<zx_rights_t>(SyscallType::kRights); |
| auto out = zx_handle_duplicate->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_handle_duplicate->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_handle_duplicate->Input<zx_rights_t>("rights", |
| std::make_unique<ArgumentAccess<zx_rights_t>>(rights)); |
| // Outputs |
| zx_handle_duplicate->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| } |
| |
| { |
| Syscall* zx_handle_replace = Add("zx_handle_replace", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_handle_replace->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto rights = zx_handle_replace->Argument<zx_rights_t>(SyscallType::kRights); |
| auto out = zx_handle_replace->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_handle_replace->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_handle_replace->Input<zx_rights_t>("rights", |
| std::make_unique<ArgumentAccess<zx_rights_t>>(rights)); |
| // Outputs |
| zx_handle_replace->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| } |
| |
| { |
| Syscall* zx_object_wait_one = Add("zx_object_wait_one", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_wait_one->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto signals = zx_object_wait_one->Argument<zx_signals_t>(SyscallType::kSignals); |
| auto deadline = zx_object_wait_one->Argument<zx_time_t>(SyscallType::kTime); |
| auto observed = zx_object_wait_one->PointerArgument<zx_signals_t>(SyscallType::kSignals); |
| // Inputs |
| zx_object_wait_one->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_wait_one->Input<zx_signals_t>( |
| "signals", std::make_unique<ArgumentAccess<zx_signals_t>>(signals)); |
| zx_object_wait_one->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| // Outputs |
| zx_object_wait_one->Output<zx_signals_t>( |
| ZX_OK, "observed", std::make_unique<ArgumentAccess<zx_signals_t>>(observed)); |
| } |
| |
| { |
| Syscall* zx_object_wait_many = Add("zx_object_wait_many", SyscallReturnType::kStatus); |
| // Arguments |
| auto items = zx_object_wait_many->PointerArgument<zx_wait_item_t>(SyscallType::kStruct); |
| auto count = zx_object_wait_many->Argument<size_t>(SyscallType::kSize); |
| auto deadline = zx_object_wait_many->Argument<zx_time_t>(SyscallType::kTime); |
| // Inputs |
| zx_object_wait_many->InputObjectArray<zx_wait_item_t, size_t>( |
| "items", std::make_unique<ArgumentAccess<zx_wait_item_t>>(items), |
| std::make_unique<ArgumentAccess<size_t>>(count), ZxWaitItem::GetClass()); |
| zx_object_wait_many->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| // Outputs |
| zx_object_wait_many->OutputObjectArray<zx_wait_item_t, size_t>( |
| ZX_OK, "items", std::make_unique<ArgumentAccess<zx_wait_item_t>>(items), |
| std::make_unique<ArgumentAccess<size_t>>(count), ZxWaitItem::GetClass()); |
| zx_object_wait_many->OutputObjectArray<zx_wait_item_t, size_t>( |
| ZX_ERR_CANCELED, "items", std::make_unique<ArgumentAccess<zx_wait_item_t>>(items), |
| std::make_unique<ArgumentAccess<size_t>>(count), ZxWaitItem::GetClass()); |
| } |
| |
| { |
| Syscall* zx_object_wait_async = Add("zx_object_wait_async", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_wait_async->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto port = zx_object_wait_async->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto key = zx_object_wait_async->Argument<uint64_t>(SyscallType::kUint64); |
| auto signals = zx_object_wait_async->Argument<zx_signals_t>(SyscallType::kSignals); |
| auto options = zx_object_wait_async->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_object_wait_async->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_wait_async->Input<zx_handle_t>("port", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(port)); |
| zx_object_wait_async->Input<uint64_t>("key", std::make_unique<ArgumentAccess<uint64_t>>(key)); |
| zx_object_wait_async->Input<zx_signals_t>( |
| "signals", std::make_unique<ArgumentAccess<zx_signals_t>>(signals)); |
| zx_object_wait_async->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| } |
| |
| { |
| Syscall* zx_object_signal = Add("zx_object_signal", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_signal->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto clear_mask = zx_object_signal->Argument<uint32_t>(SyscallType::kSignals); |
| auto set_mask = zx_object_signal->Argument<uint32_t>(SyscallType::kSignals); |
| // Inputs |
| zx_object_signal->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_signal->Input<uint32_t>("clear_mask", |
| std::make_unique<ArgumentAccess<uint32_t>>(clear_mask)); |
| zx_object_signal->Input<uint32_t>("set_mask", |
| std::make_unique<ArgumentAccess<uint32_t>>(set_mask)); |
| } |
| |
| { |
| Syscall* zx_object_signal_peer = Add("zx_object_signal_peer", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_signal_peer->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto clear_mask = zx_object_signal_peer->Argument<uint32_t>(SyscallType::kSignals); |
| auto set_mask = zx_object_signal_peer->Argument<uint32_t>(SyscallType::kSignals); |
| // Inputs |
| zx_object_signal_peer->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_signal_peer->Input<uint32_t>("clear_mask", |
| std::make_unique<ArgumentAccess<uint32_t>>(clear_mask)); |
| zx_object_signal_peer->Input<uint32_t>("set_mask", |
| std::make_unique<ArgumentAccess<uint32_t>>(set_mask)); |
| } |
| |
| { |
| Syscall* zx_object_get_property = Add("zx_object_get_property", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_get_property->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto property = zx_object_get_property->Argument<uint32_t>(SyscallType::kPropType); |
| auto value = zx_object_get_property->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto value_size = zx_object_get_property->Argument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxObjectGetProperty_ZX_PROP_NAME = 1; |
| const uint8_t kZxObjectGetProperty_ZX_PROP_PROCESS_DEBUG_ADDR = 2; |
| const uint8_t kZxObjectGetProperty_ZX_PROP_PROCESS_VDSO_BASE_ADDRESS = 3; |
| const uint8_t kZxObjectGetProperty_ZX_PROP_SOCKET_RX_THRESHOLD = 4; |
| const uint8_t kZxObjectGetProperty_ZX_PROP_SOCKET_TX_THRESHOLD = 5; |
| const uint8_t kZxObjectGetProperty_ZX_PROP_EXCEPTION_STATE = 6; |
| // Inputs |
| zx_object_get_property->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_get_property->Input<uint32_t>("property", |
| std::make_unique<ArgumentAccess<uint32_t>>(property)); |
| // Outputs |
| zx_object_get_property |
| ->OutputString<uint8_t>(ZX_OK, "value", std::make_unique<ArgumentAccess<uint8_t>>(value), |
| std::make_unique<ArgumentAccess<size_t>>(value_size)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_NAME) |
| ->SetId(kZxObjectGetProperty_ZX_PROP_NAME); |
| zx_object_get_property |
| ->OutputIndirect<uintptr_t, uint8_t>(ZX_OK, "value", SyscallType::kVaddr, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_PROCESS_DEBUG_ADDR) |
| ->SetId(kZxObjectGetProperty_ZX_PROP_PROCESS_DEBUG_ADDR); |
| zx_object_get_property |
| ->OutputIndirect<uintptr_t, uint8_t>(ZX_OK, "value", SyscallType::kVaddr, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_PROCESS_VDSO_BASE_ADDRESS) |
| ->SetId(kZxObjectGetProperty_ZX_PROP_PROCESS_VDSO_BASE_ADDRESS); |
| zx_object_get_property |
| ->OutputIndirect<size_t, uint8_t>(ZX_OK, "value", SyscallType::kSize, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_SOCKET_RX_THRESHOLD) |
| ->SetId(kZxObjectGetProperty_ZX_PROP_SOCKET_RX_THRESHOLD); |
| zx_object_get_property |
| ->OutputIndirect<size_t, uint8_t>(ZX_OK, "value", SyscallType::kSize, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_SOCKET_TX_THRESHOLD) |
| ->SetId(kZxObjectGetProperty_ZX_PROP_SOCKET_TX_THRESHOLD); |
| zx_object_get_property |
| ->OutputIndirect<uint32_t, uint8_t>(ZX_OK, "value", SyscallType::kExceptionState, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_EXCEPTION_STATE) |
| ->SetId(kZxObjectGetProperty_ZX_PROP_EXCEPTION_STATE); |
| } |
| |
| { |
| Syscall* zx_object_set_property = Add("zx_object_set_property", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_set_property->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto property = zx_object_set_property->Argument<uint32_t>(SyscallType::kPropType); |
| auto value = zx_object_set_property->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto value_size = zx_object_set_property->Argument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxObjectSetProperty_ZX_PROP_NAME = 1; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_REGISTER_FS = 2; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_REGISTER_GS = 3; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_PROCESS_DEBUG_ADDR = 4; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_SOCKET_RX_THRESHOLD = 5; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_SOCKET_TX_THRESHOLD = 6; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_JOB_KILL_ON_OOM = 7; |
| const uint8_t kZxObjectSetProperty_ZX_PROP_EXCEPTION_STATE = 8; |
| // Inputs |
| zx_object_set_property->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_set_property->Input<uint32_t>("property", |
| std::make_unique<ArgumentAccess<uint32_t>>(property)); |
| zx_object_set_property |
| ->InputString<uint8_t>("value", std::make_unique<ArgumentAccess<uint8_t>>(value), |
| std::make_unique<ArgumentAccess<size_t>>(value_size)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_NAME) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_NAME); |
| zx_object_set_property |
| ->InputIndirect<uintptr_t, uint8_t>("value", SyscallType::kVaddr, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_REGISTER_FS) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_REGISTER_FS); |
| zx_object_set_property |
| ->InputIndirect<uintptr_t, uint8_t>("value", SyscallType::kVaddr, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_REGISTER_GS) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_REGISTER_GS); |
| zx_object_set_property |
| ->InputIndirect<uintptr_t, uint8_t>("value", SyscallType::kVaddr, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_PROCESS_DEBUG_ADDR) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_PROCESS_DEBUG_ADDR); |
| zx_object_set_property |
| ->InputIndirect<size_t, uint8_t>("value", SyscallType::kSize, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_SOCKET_RX_THRESHOLD) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_SOCKET_RX_THRESHOLD); |
| zx_object_set_property |
| ->InputIndirect<size_t, uint8_t>("value", SyscallType::kSize, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_SOCKET_TX_THRESHOLD) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_SOCKET_TX_THRESHOLD); |
| zx_object_set_property |
| ->InputIndirect<size_t, uint8_t>("value", SyscallType::kSize, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_JOB_KILL_ON_OOM) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_JOB_KILL_ON_OOM); |
| zx_object_set_property |
| ->InputIndirect<uint32_t, uint8_t>("value", SyscallType::kExceptionState, |
| std::make_unique<ArgumentAccess<uint8_t>>(value)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(property), |
| ZX_PROP_EXCEPTION_STATE) |
| ->SetId(kZxObjectSetProperty_ZX_PROP_EXCEPTION_STATE); |
| } |
| |
| { |
| Syscall* zx_object_get_info = Add("zx_object_get_info", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_get_info->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto topic = |
| zx_object_get_info->Argument<zx_object_info_topic_t>(SyscallType::kObjectInfoTopic); |
| auto buffer = zx_object_get_info->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_object_get_info->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_object_get_info->PointerArgument<size_t>(SyscallType::kSize); |
| auto avail = zx_object_get_info->PointerArgument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxObjectGetInfo_ZX_INFO_HANDLE_BASIC = 1; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_HANDLE_COUNT = 2; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_HANDLE_STATS = 3; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_JOB = 4; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS = 5; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_THREADS_actual = 6; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_THREADS_info = 7; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_THREAD = 8; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_THREAD_EXCEPTION_REPORT = 9; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_THREAD_STATS = 10; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_CPU_STATS = 11; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_VMAR = 12; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_VMO = 13; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_SOCKET = 14; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_TIMER = 15; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_JOB_CHILDREN_actual = 16; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_JOB_CHILDREN_info = 17; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_JOB_PROCESSES_actual = 18; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_JOB_PROCESSES_info = 19; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_TASK_STATS = 20; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_MAPS_actual = 21; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_MAPS_info = 22; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_VMOS_actual = 23; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_PROCESS_VMOS_info = 24; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_KMEM_STATS = 25; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_RESOURCE = 26; |
| const uint8_t kZxObjectGetInfo_ZX_INFO_BTI = 27; |
| |
| // Inputs |
| zx_object_get_info->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_get_info->Input<uint32_t>("topic", std::make_unique<ArgumentAccess<uint32_t>>(topic)); |
| zx_object_get_info->Input<size_t>("buffer_size", |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_object_get_info |
| ->OutputObject<zx_info_handle_basic_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoHandleBasic::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_HANDLE_BASIC) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_HANDLE_BASIC); |
| zx_object_get_info |
| ->OutputObject<zx_info_handle_count_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoHandleCount::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_HANDLE_COUNT) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_HANDLE_COUNT); |
| zx_object_get_info |
| ->OutputObject<zx_info_process_handle_stats_t>( |
| ZX_OK, "info", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoProcessHandleStats::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_HANDLE_STATS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_HANDLE_STATS); |
| zx_object_get_info |
| ->OutputObject<zx_info_job_t>( |
| ZX_OK, "info", std::make_unique<ArgumentAccess<uint8_t>>(buffer), ZxInfoJob::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), ZX_INFO_JOB) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_JOB); |
| zx_object_get_info |
| ->OutputObject<zx_info_process_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoProcess::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS); |
| zx_object_get_info |
| ->OutputActualAndRequested<size_t>(ZX_OK, "actual", |
| std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(avail)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_THREADS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_THREADS_actual); |
| zx_object_get_info |
| ->OutputBuffer<zx_koid_t, uint8_t, size_t>( |
| ZX_OK, "info", SyscallType::kKoid, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_THREADS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_THREADS_info); |
| zx_object_get_info |
| ->OutputObject<zx_info_thread_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoThread::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_THREAD) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_THREAD); |
| zx_object_get_info |
| ->OutputObject<zx_exception_report_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxExceptionReport::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_THREAD_EXCEPTION_REPORT) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_THREAD_EXCEPTION_REPORT); |
| zx_object_get_info |
| ->OutputObject<zx_info_thread_stats_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoThreadStats::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_THREAD_STATS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_THREAD_STATS); |
| zx_object_get_info |
| ->OutputObject<zx_info_cpu_stats_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoCpuStats::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_CPU_STATS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_CPU_STATS); |
| zx_object_get_info |
| ->OutputObject<zx_info_vmar_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoVmar::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), ZX_INFO_VMAR) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_VMAR); |
| zx_object_get_info |
| ->OutputObject<zx_info_vmo_t>( |
| ZX_OK, "info", std::make_unique<ArgumentAccess<uint8_t>>(buffer), ZxInfoVmo::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), ZX_INFO_VMO) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_VMO); |
| zx_object_get_info |
| ->OutputObject<zx_info_socket_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoSocket::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_SOCKET) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_SOCKET); |
| zx_object_get_info |
| ->OutputObject<zx_info_timer_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoTimer::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), ZX_INFO_TIMER) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_TIMER); |
| zx_object_get_info |
| ->OutputActualAndRequested<size_t>(ZX_OK, "actual", |
| std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(avail)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_JOB_CHILDREN) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_JOB_CHILDREN_actual); |
| zx_object_get_info |
| ->OutputBuffer<zx_koid_t, uint8_t, size_t>( |
| ZX_OK, "info", SyscallType::kKoid, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_JOB_CHILDREN) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_JOB_CHILDREN_info); |
| zx_object_get_info |
| ->OutputActualAndRequested<size_t>(ZX_OK, "actual", |
| std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(avail)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_JOB_PROCESSES) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_JOB_PROCESSES_actual); |
| zx_object_get_info |
| ->OutputBuffer<zx_koid_t, uint8_t, size_t>( |
| ZX_OK, "info", SyscallType::kKoid, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_JOB_PROCESSES) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_JOB_PROCESSES_info); |
| zx_object_get_info |
| ->OutputObject<zx_info_task_stats_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoTaskStats::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_TASK_STATS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_TASK_STATS); |
| zx_object_get_info |
| ->OutputActualAndRequested<size_t>(ZX_OK, "actual", |
| std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(avail)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_MAPS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_MAPS_actual); |
| zx_object_get_info |
| ->OutputObjectArray<zx_info_maps_t, size_t>( |
| ZX_OK, "info", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual), ZxInfoMaps::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_MAPS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_MAPS_info); |
| zx_object_get_info |
| ->OutputActualAndRequested<size_t>(ZX_OK, "actual", |
| std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(avail)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_VMOS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_VMOS_actual); |
| zx_object_get_info |
| ->OutputObjectArray<zx_info_vmo_t, size_t>( |
| ZX_OK, "info", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual), ZxInfoVmo::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_PROCESS_VMOS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_PROCESS_VMOS_info); |
| zx_object_get_info |
| ->OutputObject<zx_info_kmem_stats_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoKmemStats::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_KMEM_STATS) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_KMEM_STATS); |
| zx_object_get_info |
| ->OutputObject<zx_info_resource_t>(ZX_OK, "info", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxInfoResource::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_INFO_RESOURCE) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_RESOURCE); |
| zx_object_get_info |
| ->OutputObject<zx_info_bti_t>( |
| ZX_OK, "info", std::make_unique<ArgumentAccess<uint8_t>>(buffer), ZxInfoBti::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), ZX_INFO_BTI) |
| ->SetId(kZxObjectGetInfo_ZX_INFO_BTI); |
| } |
| |
| { |
| Syscall* zx_object_get_child = Add("zx_object_get_child", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_get_child->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto koid = zx_object_get_child->Argument<uint64_t>(SyscallType::kUint64); |
| auto rights = zx_object_get_child->Argument<zx_rights_t>(SyscallType::kRights); |
| auto out = zx_object_get_child->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_object_get_child->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_get_child->Input<uint64_t>("koid", std::make_unique<ArgumentAccess<uint64_t>>(koid)); |
| zx_object_get_child->Input<zx_rights_t>("rights", |
| std::make_unique<ArgumentAccess<zx_rights_t>>(rights)); |
| // Outputs |
| zx_object_get_child->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| } |
| |
| { |
| Syscall* zx_object_set_profile = Add("zx_object_set_profile", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_object_set_profile->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto profile = zx_object_set_profile->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_object_set_profile->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_object_set_profile->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_object_set_profile->Input<zx_handle_t>( |
| "profile", std::make_unique<ArgumentAccess<zx_handle_t>>(profile)); |
| zx_object_set_profile->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| } |
| |
| { |
| Syscall* zx_channel_create = Add("zx_channel_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_channel_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out0 = zx_channel_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto out1 = zx_channel_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_channel_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_channel_create->Output<zx_handle_t>(ZX_OK, "out0", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out0)); |
| zx_channel_create->Output<zx_handle_t>(ZX_OK, "out1", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out1)); |
| |
| zx_channel_create->set_inference(&SyscallDecoderDispatcher::ZxChannelCreate); |
| |
| zx_channel_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out0 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out0", /*invoked=*/false)); |
| FX_DCHECK(out0 != nullptr); |
| out0->AddCreationEvent(event); |
| auto out1 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out1", /*invoked=*/false)); |
| FX_DCHECK(out1 != nullptr); |
| out1->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_channel_read = |
| Add("zx_channel_read", SyscallReturnType::kStatus, SyscallKind::kChannelRead); |
| // Arguments |
| auto handle = zx_channel_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_channel_read->Argument<uint32_t>(SyscallType::kChannelOption); |
| auto bytes = zx_channel_read->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto handles = zx_channel_read->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto num_bytes = zx_channel_read->Argument<uint32_t>(SyscallType::kUint32); |
| auto num_handles = zx_channel_read->Argument<uint32_t>(SyscallType::kUint32); |
| auto actual_bytes = zx_channel_read->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto actual_handles = zx_channel_read->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_channel_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_channel_read->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_channel_read->Input<uint32_t>("num_bytes", |
| std::make_unique<ArgumentAccess<uint32_t>>(num_bytes)); |
| zx_channel_read->Input<uint32_t>("num_handles", |
| std::make_unique<ArgumentAccess<uint32_t>>(num_handles)); |
| // Outputs |
| zx_channel_read->OutputFidlMessageHandle( |
| ZX_OK, "", fidl_codec::SyscallFidlType::kInputMessage, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<ArgumentAccess<uint8_t>>(bytes), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes), |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handles), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| zx_channel_read->Output<uint32_t>(ZX_ERR_BUFFER_TOO_SMALL, "actual_bytes", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes)); |
| zx_channel_read->Output<uint32_t>(ZX_ERR_BUFFER_TOO_SMALL, "actual_handles", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| |
| zx_channel_read->set_inference(&SyscallDecoderDispatcher::ZxChannelRead); |
| |
| zx_channel_read->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::FidlMessageValue* message = event->GetMessage(); |
| if ((message != nullptr) && !message->unknown_direction()) { |
| CreateHandleVisitor visitor(event); |
| message->Visit(&visitor, nullptr); |
| event->thread()->process()->AddEvent(event, message); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_channel_read_etc = |
| Add("zx_channel_read_etc", SyscallReturnType::kStatus, SyscallKind::kChannelRead); |
| // Arguments |
| auto handle = zx_channel_read_etc->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_channel_read_etc->Argument<uint32_t>(SyscallType::kChannelOption); |
| auto bytes = zx_channel_read_etc->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto handles = zx_channel_read_etc->PointerArgument<zx_handle_info_t>(SyscallType::kHandle); |
| auto num_bytes = zx_channel_read_etc->Argument<uint32_t>(SyscallType::kUint32); |
| auto num_handles = zx_channel_read_etc->Argument<uint32_t>(SyscallType::kUint32); |
| auto actual_bytes = zx_channel_read_etc->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto actual_handles = zx_channel_read_etc->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_channel_read_etc->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_channel_read_etc->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_channel_read_etc->Input<uint32_t>("num_bytes", |
| std::make_unique<ArgumentAccess<uint32_t>>(num_bytes)); |
| zx_channel_read_etc->Input<uint32_t>("num_handles", |
| std::make_unique<ArgumentAccess<uint32_t>>(num_handles)); |
| // Outputs |
| zx_channel_read_etc->OutputFidlMessageHandleInfo( |
| ZX_OK, "", fidl_codec::SyscallFidlType::kInputMessage, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<ArgumentAccess<uint8_t>>(bytes), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes), |
| std::make_unique<ArgumentAccess<zx_handle_info_t>>(handles), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| zx_channel_read_etc->Output<uint32_t>(ZX_ERR_BUFFER_TOO_SMALL, "actual_bytes", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes)); |
| zx_channel_read_etc->Output<uint32_t>( |
| ZX_ERR_BUFFER_TOO_SMALL, "actual_handles", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| |
| zx_channel_read_etc->set_inference(&SyscallDecoderDispatcher::ZxChannelRead); |
| |
| zx_channel_read_etc->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::FidlMessageValue* message = event->GetMessage(); |
| if ((message != nullptr) && !message->unknown_direction()) { |
| CreateHandleVisitor visitor(event); |
| message->Visit(&visitor, nullptr); |
| event->thread()->process()->AddEvent(event, message); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_channel_write = |
| Add("zx_channel_write", SyscallReturnType::kStatus, SyscallKind::kChannelWrite); |
| // Arguments |
| auto handle = zx_channel_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_channel_write->Argument<uint32_t>(SyscallType::kChannelOption); |
| auto bytes = zx_channel_write->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto num_bytes = zx_channel_write->Argument<uint32_t>(SyscallType::kUint32); |
| auto handles = zx_channel_write->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto num_handles = zx_channel_write->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_channel_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_channel_write->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_channel_write->InputFidlMessageHandle( |
| "", fidl_codec::SyscallFidlType::kOutputMessage, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<ArgumentAccess<uint8_t>>(bytes), |
| std::make_unique<ArgumentAccess<uint32_t>>(num_bytes), |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handles), |
| std::make_unique<ArgumentAccess<uint32_t>>(num_handles)); |
| |
| zx_channel_write->set_inference(&SyscallDecoderDispatcher::ZxChannelWrite); |
| |
| zx_channel_write->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::FidlMessageValue* message = event->invoked_event()->GetMessage(); |
| if ((message != nullptr) && !message->unknown_direction()) { |
| CloseHandleVisitor visitor(event); |
| message->Visit(&visitor, nullptr); |
| event->thread()->process()->AddEvent(event, message); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_channel_write_etc = |
| Add("zx_channel_write_etc", SyscallReturnType::kStatus, SyscallKind::kChannelWrite); |
| // Arguments |
| auto handle = zx_channel_write_etc->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_channel_write_etc->Argument<uint32_t>(SyscallType::kChannelOption); |
| auto bytes = zx_channel_write_etc->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto num_bytes = zx_channel_write_etc->Argument<uint32_t>(SyscallType::kUint32); |
| auto handles = |
| zx_channel_write_etc->PointerArgument<zx_handle_disposition_t>(SyscallType::kHandle); |
| auto num_handles = zx_channel_write_etc->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_channel_write_etc->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_channel_write_etc->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_channel_write_etc->InputFidlMessageHandleDisposition( |
| "", fidl_codec::SyscallFidlType::kOutputMessage, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<ArgumentAccess<uint8_t>>(bytes), |
| std::make_unique<ArgumentAccess<uint32_t>>(num_bytes), |
| std::make_unique<ArgumentAccess<zx_handle_disposition_t>>(handles), |
| std::make_unique<ArgumentAccess<uint32_t>>(num_handles)); |
| |
| zx_channel_write_etc->set_inference(&SyscallDecoderDispatcher::ZxChannelWrite); |
| |
| zx_channel_write_etc->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::FidlMessageValue* message = event->invoked_event()->GetMessage(); |
| if ((message != nullptr) && !message->unknown_direction()) { |
| CloseHandleVisitor visitor(event); |
| message->Visit(&visitor, nullptr); |
| event->thread()->process()->AddEvent(event, message); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_channel_call = |
| Add("zx_channel_call", SyscallReturnType::kStatus, SyscallKind::kChannelCall); |
| // Arguments |
| auto handle = zx_channel_call->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_channel_call->Argument<uint32_t>(SyscallType::kChannelOption); |
| auto deadline = zx_channel_call->Argument<zx_time_t>(SyscallType::kTime); |
| auto args = zx_channel_call->PointerArgument<zx_channel_call_args_t>(SyscallType::kStruct); |
| auto actual_bytes = zx_channel_call->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto actual_handles = zx_channel_call->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_channel_call->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_channel_call->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_channel_call->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| zx_channel_call->Input<uint32_t>( |
| "rd_num_bytes", std::make_unique<FieldAccess<zx_channel_call_args, uint32_t>>( |
| args, ZxChannelCallArgs::rd_num_bytes, SyscallType::kUint32)); |
| zx_channel_call->Input<uint32_t>( |
| "rd_num_handles", std::make_unique<FieldAccess<zx_channel_call_args, uint32_t>>( |
| args, ZxChannelCallArgs::rd_num_handles, SyscallType::kUint32)); |
| zx_channel_call->InputFidlMessageHandle( |
| "", fidl_codec::SyscallFidlType::kOutputRequest, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<PointerFieldAccess<zx_channel_call_args, uint8_t>>( |
| args, ZxChannelCallArgs::wr_bytes, SyscallType::kUint8), |
| std::make_unique<FieldAccess<zx_channel_call_args, uint32_t>>( |
| args, ZxChannelCallArgs::wr_num_bytes, SyscallType::kUint32), |
| std::make_unique<PointerFieldAccess<zx_channel_call_args, zx_handle_t>>( |
| args, ZxChannelCallArgs::wr_handles, SyscallType::kHandle), |
| std::make_unique<FieldAccess<zx_channel_call_args, uint32_t>>( |
| args, ZxChannelCallArgs::wr_num_handles, SyscallType::kUint32)); |
| // Outputs |
| zx_channel_call->OutputFidlMessageHandle( |
| ZX_OK, "", fidl_codec::SyscallFidlType::kInputResponse, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<PointerFieldAccess<zx_channel_call_args, uint8_t>>( |
| args, ZxChannelCallArgs::rd_bytes, SyscallType::kUint8), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes), |
| std::make_unique<PointerFieldAccess<zx_channel_call_args, zx_handle_t>>( |
| args, ZxChannelCallArgs::rd_handles, SyscallType::kHandle), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| zx_channel_call->Output<uint32_t>(ZX_ERR_BUFFER_TOO_SMALL, "actual_bytes", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes)); |
| zx_channel_call->Output<uint32_t>(ZX_ERR_BUFFER_TOO_SMALL, "actual_handles", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| |
| zx_channel_call->set_inference(&SyscallDecoderDispatcher::ZxChannelCall); |
| |
| zx_channel_call->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::FidlMessageValue* request = event->invoked_event()->GetMessage(); |
| if (request != nullptr) { |
| CloseHandleVisitor close_handle_visitor(event); |
| request->Visit(&close_handle_visitor, nullptr); |
| event->thread()->process()->AddEvent(event, request); |
| } |
| const fidl_codec::FidlMessageValue* response = event->GetMessage(); |
| if (response != nullptr) { |
| CreateHandleVisitor create_handle_visitor(event); |
| response->Visit(&create_handle_visitor, nullptr); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_channel_call_etc = |
| Add("zx_channel_call_etc", SyscallReturnType::kStatus, SyscallKind::kChannelCall); |
| // Arguments |
| auto handle = zx_channel_call_etc->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_channel_call_etc->Argument<uint32_t>(SyscallType::kChannelOption); |
| auto deadline = zx_channel_call_etc->Argument<zx_time_t>(SyscallType::kTime); |
| auto args = |
| zx_channel_call_etc->PointerArgument<zx_channel_call_etc_args_t>(SyscallType::kStruct); |
| auto actual_bytes = zx_channel_call_etc->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto actual_handles = zx_channel_call_etc->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_channel_call_etc->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_channel_call_etc->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_channel_call_etc->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| zx_channel_call_etc->Input<uint32_t>( |
| "rd_num_bytes", std::make_unique<FieldAccess<zx_channel_call_etc_args, uint32_t>>( |
| args, ZxChannelCallEtcArgs::rd_num_bytes, SyscallType::kUint32)); |
| zx_channel_call_etc->Input<uint32_t>( |
| "rd_num_handles", std::make_unique<FieldAccess<zx_channel_call_etc_args, uint32_t>>( |
| args, ZxChannelCallEtcArgs::rd_num_handles, SyscallType::kUint32)); |
| zx_channel_call_etc->InputFidlMessageHandleDisposition( |
| "", fidl_codec::SyscallFidlType::kOutputRequest, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<PointerFieldAccess<zx_channel_call_etc_args, uint8_t>>( |
| args, ZxChannelCallEtcArgs::wr_bytes, SyscallType::kUint8), |
| std::make_unique<FieldAccess<zx_channel_call_etc_args, uint32_t>>( |
| args, ZxChannelCallEtcArgs::wr_num_bytes, SyscallType::kUint32), |
| std::make_unique<PointerFieldAccess<zx_channel_call_etc_args, zx_handle_disposition_t>>( |
| args, ZxChannelCallEtcArgs::wr_handles, SyscallType::kHandle), |
| std::make_unique<FieldAccess<zx_channel_call_etc_args, uint32_t>>( |
| args, ZxChannelCallEtcArgs::wr_num_handles, SyscallType::kUint32)); |
| // Outputs |
| zx_channel_call_etc->OutputFidlMessageHandleInfo( |
| ZX_OK, "", fidl_codec::SyscallFidlType::kInputResponse, |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle), |
| std::make_unique<ArgumentAccess<uint32_t>>(options), |
| std::make_unique<PointerFieldAccess<zx_channel_call_etc_args, uint8_t>>( |
| args, ZxChannelCallEtcArgs::rd_bytes, SyscallType::kUint8), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes), |
| std::make_unique<PointerFieldAccess<zx_channel_call_etc_args, zx_handle_info_t>>( |
| args, ZxChannelCallEtcArgs::rd_handles, SyscallType::kHandle), |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| zx_channel_call_etc->Output<uint32_t>(ZX_ERR_BUFFER_TOO_SMALL, "actual_bytes", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_bytes)); |
| zx_channel_call_etc->Output<uint32_t>( |
| ZX_ERR_BUFFER_TOO_SMALL, "actual_handles", |
| std::make_unique<ArgumentAccess<uint32_t>>(actual_handles)); |
| |
| zx_channel_call_etc->set_inference(&SyscallDecoderDispatcher::ZxChannelCall); |
| |
| zx_channel_call_etc->set_compute_statistics([](const OutputEvent* event) { |
| const fidl_codec::FidlMessageValue* request = event->invoked_event()->GetMessage(); |
| if (request != nullptr) { |
| CloseHandleVisitor close_handle_visitor(event); |
| request->Visit(&close_handle_visitor, nullptr); |
| event->thread()->process()->AddEvent(event, request); |
| } |
| const fidl_codec::FidlMessageValue* response = event->GetMessage(); |
| if (response != nullptr) { |
| CreateHandleVisitor create_handle_visitor(event); |
| response->Visit(&create_handle_visitor, nullptr); |
| } |
| }); |
| } |
| |
| { |
| Syscall* zx_socket_create = Add("zx_socket_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_socket_create->Argument<uint32_t>(SyscallType::kSocketCreateOptions); |
| auto out0 = zx_socket_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto out1 = zx_socket_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_socket_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_socket_create->Output<zx_handle_t>(ZX_OK, "out0", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out0)); |
| zx_socket_create->Output<zx_handle_t>(ZX_OK, "out1", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out1)); |
| |
| zx_socket_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out0 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out0", /*invoked=*/false)); |
| FX_DCHECK(out0 != nullptr); |
| out0->AddCreationEvent(event); |
| auto out1 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out1", /*invoked=*/false)); |
| FX_DCHECK(out1 != nullptr); |
| out1->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_socket_write = Add("zx_socket_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_socket_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_socket_write->Argument<uint32_t>(SyscallType::kUint32); |
| auto buffer = zx_socket_write->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_socket_write->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_socket_write->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_socket_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_socket_write->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_socket_write->InputBuffer<uint8_t, uint8_t, size_t>( |
| "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_socket_write->OutputActualAndRequested<size_t>( |
| ZX_OK, "actual", std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_socket_read = Add("zx_socket_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_socket_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_socket_read->Argument<uint32_t>(SyscallType::kSocketReadOptions); |
| auto buffer = zx_socket_read->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_socket_read->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_socket_read->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_socket_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_socket_read->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_socket_read->Input<size_t>("buffer_size", |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_socket_read->OutputActualAndRequested<size_t>( |
| ZX_OK, "actual", std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| zx_socket_read->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual)); |
| } |
| |
| { |
| Syscall* zx_socket_set_disposition = |
| Add("zx_socket_set_disposition", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_socket_set_disposition->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto disposition = |
| zx_socket_set_disposition->Argument<uint32_t>(SyscallType::kSocketDisposition); |
| auto disposition_peer = |
| zx_socket_set_disposition->Argument<uint32_t>(SyscallType::kSocketDisposition); |
| // Inputs |
| zx_socket_set_disposition->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_socket_set_disposition->Input<uint32_t>( |
| "disposition", std::make_unique<ArgumentAccess<uint32_t>>(disposition)); |
| zx_socket_set_disposition->Input<uint32_t>( |
| "disposition_peer", std::make_unique<ArgumentAccess<uint32_t>>(disposition_peer)); |
| } |
| |
| { Add("zx_thread_exit", SyscallReturnType::kNoReturn); } |
| |
| { |
| Syscall* zx_thread_create = Add("zx_thread_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto process = zx_thread_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto name = zx_thread_create->PointerArgument<char>(SyscallType::kChar); |
| auto name_size = zx_thread_create->Argument<size_t>(SyscallType::kSize); |
| auto options = zx_thread_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_thread_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_thread_create->Input<zx_handle_t>("process", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(process)); |
| zx_thread_create->InputString<char>("name", std::make_unique<ArgumentAccess<char>>(name), |
| std::make_unique<ArgumentAccess<size_t>>(name_size)); |
| zx_thread_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_thread_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_thread_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_thread_start = Add("zx_thread_start", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_thread_start->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto thread_entry = zx_thread_start->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto stack = zx_thread_start->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto arg1 = zx_thread_start->Argument<uintptr_t>(SyscallType::kUintptr); |
| auto arg2 = zx_thread_start->Argument<uintptr_t>(SyscallType::kUintptr); |
| // Inputs |
| zx_thread_start->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_thread_start->Input<zx_vaddr_t>("thread_entry", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(thread_entry)); |
| zx_thread_start->Input<zx_vaddr_t>("stack", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(stack)); |
| zx_thread_start->Input<uintptr_t>("arg1", std::make_unique<ArgumentAccess<uintptr_t>>(arg1)); |
| zx_thread_start->Input<uintptr_t>("arg2", std::make_unique<ArgumentAccess<uintptr_t>>(arg2)); |
| } |
| |
| { |
| Syscall* zx_thread_read_state = Add("zx_thread_read_state", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_thread_read_state->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_thread_read_state->Argument<uint32_t>(SyscallType::kThreadStateTopic); |
| auto buffer = zx_thread_read_state->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_thread_read_state->Argument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_GENERAL_REGS_Arm64 = 1; |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_GENERAL_REGS_X64 = 2; |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_FP_REGS_X64 = 3; |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_VECTOR_REGS_Arm64 = 4; |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_VECTOR_REGS_X64 = 5; |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_DEBUG_REGS_Arm64 = 6; |
| const uint8_t kZxThreadReadState_ZX_THREAD_STATE_DEBUG_REGS_X64 = 7; |
| // Inputs |
| zx_thread_read_state->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_thread_read_state->Input<uint32_t>("kind", std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| zx_thread_read_state->Input<size_t>("buffer_size", |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_general_regs_aarch64_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateGeneralRegsAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_GENERAL_REGS) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_GENERAL_REGS_Arm64); |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_general_regs_x86_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateGeneralRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_GENERAL_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_GENERAL_REGS_X64); |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_fp_regs_x86_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateFpRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_FP_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_FP_REGS_X64); |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_vector_regs_aarch64_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateVectorRegsAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_VECTOR_REGS) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_VECTOR_REGS_Arm64); |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_vector_regs_x86_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateVectorRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_VECTOR_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_VECTOR_REGS_X64); |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_debug_regs_aarch64_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateDebugRegsAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_DEBUG_REGS) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_DEBUG_REGS_Arm64); |
| zx_thread_read_state |
| ->OutputObject<zx_thread_state_debug_regs_x86_t>( |
| ZX_OK, "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateDebugRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_DEBUG_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadReadState_ZX_THREAD_STATE_DEBUG_REGS_X64); |
| zx_thread_read_state |
| ->OutputIndirect<zx_thread_state_single_step_t, uint8_t>( |
| ZX_OK, "single_step", SyscallType::kUint32, |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_SINGLE_STEP); |
| } |
| |
| { |
| Syscall* zx_thread_write_state = Add("zx_thread_write_state", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_thread_write_state->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_thread_write_state->Argument<uint32_t>(SyscallType::kThreadStateTopic); |
| auto buffer = zx_thread_write_state->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_thread_write_state->Argument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_GENERAL_REGS_Arm64 = 1; |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_GENERAL_REGS_X64 = 2; |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_FP_REGS_X64 = 3; |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_VECTOR_REGS_Arm64 = 4; |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_VECTOR_REGS_X64 = 5; |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_DEBUG_REGS_Arm64 = 6; |
| const uint8_t kZxThreadWriteState_ZX_THREAD_STATE_DEBUG_REGS_X64 = 7; |
| // Inputs |
| zx_thread_write_state->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_thread_write_state->Input<uint32_t>("kind", |
| std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| zx_thread_write_state->Input<size_t>("buffer_size", |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_general_regs_aarch64_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateGeneralRegsAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_GENERAL_REGS) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_GENERAL_REGS_Arm64); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_general_regs_x86_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateGeneralRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_GENERAL_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_GENERAL_REGS_X64); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_fp_regs_x86_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateFpRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_FP_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_FP_REGS_X64); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_vector_regs_aarch64_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateVectorRegsAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_VECTOR_REGS) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_VECTOR_REGS_Arm64); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_vector_regs_x86_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateVectorRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_VECTOR_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_VECTOR_REGS_X64); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_debug_regs_aarch64_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateDebugRegsAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_DEBUG_REGS) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_DEBUG_REGS_Arm64); |
| zx_thread_write_state |
| ->InputObject<zx_thread_state_debug_regs_x86_t>( |
| "regs", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxThreadStateDebugRegsX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_DEBUG_REGS) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxThreadWriteState_ZX_THREAD_STATE_DEBUG_REGS_X64); |
| zx_thread_write_state |
| ->InputIndirect<zx_thread_state_single_step_t, uint8_t>( |
| "single_step", SyscallType::kUint32, std::make_unique<ArgumentAccess<uint8_t>>(buffer)) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), |
| ZX_THREAD_STATE_SINGLE_STEP); |
| } |
| |
| { |
| Syscall* zx_process_exit = Add("zx_process_exit", SyscallReturnType::kNoReturn); |
| // Arguments |
| auto retcode = zx_process_exit->Argument<int64_t>(SyscallType::kInt64); |
| // Inputs |
| zx_process_exit->Input<int64_t>("retcode", std::make_unique<ArgumentAccess<int64_t>>(retcode)); |
| } |
| |
| { |
| Syscall* zx_process_create = Add("zx_process_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto job = zx_process_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto name = zx_process_create->PointerArgument<char>(SyscallType::kChar); |
| auto name_size = zx_process_create->Argument<size_t>(SyscallType::kSize); |
| auto options = zx_process_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto proc_handle = zx_process_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto vmar_handle = zx_process_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_process_create->Input<zx_handle_t>("job", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(job)); |
| zx_process_create->InputString<char>("name", std::make_unique<ArgumentAccess<char>>(name), |
| std::make_unique<ArgumentAccess<size_t>>(name_size)); |
| zx_process_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_process_create->Output<zx_handle_t>( |
| ZX_OK, "proc_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(proc_handle)); |
| zx_process_create->Output<zx_handle_t>( |
| ZX_OK, "vmar_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(vmar_handle)); |
| |
| zx_process_create->set_compute_statistics([](const OutputEvent* event) { |
| auto proc_handle = event->GetHandleInfo( |
| event->syscall()->SearchInlineMember("proc_handle", /*invoked=*/false)); |
| FX_DCHECK(proc_handle != nullptr); |
| proc_handle->AddCreationEvent(event); |
| auto vmar_handle = event->GetHandleInfo( |
| event->syscall()->SearchInlineMember("vmar_handle", /*invoked=*/false)); |
| FX_DCHECK(vmar_handle != nullptr); |
| vmar_handle->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_process_start = Add("zx_process_start", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_process_start->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto thread = zx_process_start->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto entry = zx_process_start->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto stack = zx_process_start->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto arg1 = zx_process_start->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto arg2 = zx_process_start->Argument<uintptr_t>(SyscallType::kUintptr); |
| // Inputs |
| zx_process_start->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_process_start->Input<zx_handle_t>("thread", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(thread)); |
| zx_process_start->Input<zx_vaddr_t>("entry", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(entry)); |
| zx_process_start->Input<zx_vaddr_t>("stack", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(stack)); |
| zx_process_start->Input<zx_handle_t>("arg1", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(arg1)); |
| zx_process_start->Input<uintptr_t>("arg2", std::make_unique<ArgumentAccess<uintptr_t>>(arg2)); |
| } |
| |
| { |
| Syscall* zx_process_read_memory = Add("zx_process_read_memory", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_process_read_memory->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vaddr = zx_process_read_memory->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto buffer = zx_process_read_memory->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_process_read_memory->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_process_read_memory->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_process_read_memory->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_process_read_memory->Input<zx_vaddr_t>("vaddr", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(vaddr)); |
| zx_process_read_memory->Input<size_t>("buffer_size", |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_process_read_memory->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual)); |
| } |
| |
| { |
| Syscall* zx_process_write_memory = Add("zx_process_write_memory", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_process_write_memory->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vaddr = zx_process_write_memory->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto buffer = zx_process_write_memory->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_process_write_memory->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_process_write_memory->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_process_write_memory->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_process_write_memory->Input<zx_vaddr_t>("vaddr", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(vaddr)); |
| zx_process_write_memory->InputBuffer<uint8_t, uint8_t, size_t>( |
| "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| // Outputs |
| zx_process_write_memory->Output<size_t>(ZX_OK, "actual", |
| std::make_unique<ArgumentAccess<size_t>>(actual)); |
| } |
| |
| { |
| Syscall* zx_job_create = Add("zx_job_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto parent_job = zx_job_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_job_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_job_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_job_create->Input<zx_handle_t>("parent_job", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(parent_job)); |
| zx_job_create->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_job_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_job_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_job_set_policy = Add("zx_job_set_policy", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_job_set_policy->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_job_set_policy->Argument<uint32_t>(SyscallType::kUint32); |
| auto topic = zx_job_set_policy->Argument<uint32_t>(SyscallType::kPolicyTopic); |
| auto policy = zx_job_set_policy->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto count = zx_job_set_policy->Argument<uint32_t>(SyscallType::kUint32); |
| // Conditional field Ids |
| const uint8_t kZxJobSetPolicy_ZX_JOB_POL_BASIC = 1; |
| const uint8_t kZxJobSetPolicy_ZX_JOB_POL_TIMER_SLACK = 2; |
| // Inputs |
| zx_job_set_policy->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_job_set_policy->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_job_set_policy->Input<uint32_t>("topic", std::make_unique<ArgumentAccess<uint32_t>>(topic)); |
| zx_job_set_policy |
| ->InputObjectArray<zx_policy_basic_t, uint32_t>( |
| "policy", std::make_unique<ArgumentAccess<uint8_t>>(policy), |
| std::make_unique<ArgumentAccess<uint32_t>>(count), ZxPolicyBasic::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_JOB_POL_BASIC) |
| ->SetId(kZxJobSetPolicy_ZX_JOB_POL_BASIC); |
| zx_job_set_policy |
| ->InputObject<zx_policy_timer_slack_t>("policy", |
| std::make_unique<ArgumentAccess<uint8_t>>(policy), |
| ZxPolicyTimerSlack::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(topic), |
| ZX_JOB_POL_TIMER_SLACK) |
| ->SetId(kZxJobSetPolicy_ZX_JOB_POL_TIMER_SLACK); |
| } |
| |
| { |
| Syscall* zx_task_suspend = Add("zx_task_suspend", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_task_suspend->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto token = zx_task_suspend->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_task_suspend->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_task_suspend->Output<zx_handle_t>(ZX_OK, "token", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(token)); |
| } |
| |
| { |
| Syscall* zx_task_suspend_token = Add("zx_task_suspend_token", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_task_suspend_token->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto token = zx_task_suspend_token->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_task_suspend_token->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_task_suspend_token->Output<zx_handle_t>( |
| ZX_OK, "token", std::make_unique<ArgumentAccess<zx_handle_t>>(token)); |
| } |
| |
| { |
| Syscall* zx_task_create_exception_channel = |
| Add("zx_task_create_exception_channel", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_task_create_exception_channel->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_task_create_exception_channel->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_task_create_exception_channel->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_task_create_exception_channel->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_task_create_exception_channel->Input<uint32_t>( |
| "options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_task_create_exception_channel->Output<zx_handle_t>( |
| ZX_OK, "out", std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_task_create_exception_channel->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_task_kill = Add("zx_task_kill", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_task_kill->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_task_kill->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_exception_get_thread = Add("zx_exception_get_thread", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_exception_get_thread->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto out = zx_exception_get_thread->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_exception_get_thread->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_exception_get_thread->Output<zx_handle_t>( |
| ZX_OK, "out", std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| } |
| |
| { |
| Syscall* zx_exception_get_process = Add("zx_exception_get_process", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_exception_get_process->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto out = zx_exception_get_process->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_exception_get_process->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_exception_get_process->Output<zx_handle_t>( |
| ZX_OK, "out", std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| } |
| |
| { |
| Syscall* zx_event_create = Add("zx_event_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_event_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_event_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_event_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_event_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_event_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_eventpair_create = Add("zx_eventpair_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_eventpair_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out0 = zx_eventpair_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto out1 = zx_eventpair_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_eventpair_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_eventpair_create->Output<zx_handle_t>(ZX_OK, "out0", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out0)); |
| zx_eventpair_create->Output<zx_handle_t>(ZX_OK, "out1", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out1)); |
| |
| zx_eventpair_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out0 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out0", /*invoked=*/false)); |
| FX_DCHECK(out0 != nullptr); |
| out0->AddCreationEvent(event); |
| auto out1 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out1", /*invoked=*/false)); |
| FX_DCHECK(out1 != nullptr); |
| out1->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_futex_wait = Add("zx_futex_wait", SyscallReturnType::kStatus); |
| // Arguments |
| auto value_ptr = zx_futex_wait->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto current_value = zx_futex_wait->Argument<zx_futex_t>(SyscallType::kFutex); |
| auto new_futex_owner = zx_futex_wait->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto deadline = zx_futex_wait->Argument<zx_time_t>(SyscallType::kTime); |
| // Inputs |
| zx_futex_wait->Input<zx_futex_t>("value_ptr", |
| std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| zx_futex_wait->Input<zx_futex_t>("current_value", |
| std::make_unique<ArgumentAccess<zx_futex_t>>(current_value)); |
| zx_futex_wait->Input<zx_handle_t>( |
| "new_futex_owner", std::make_unique<ArgumentAccess<zx_handle_t>>(new_futex_owner)); |
| zx_futex_wait->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| } |
| |
| { |
| Syscall* zx_futex_wake = Add("zx_futex_wake", SyscallReturnType::kStatus); |
| // Arguments |
| auto value_ptr = zx_futex_wake->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto wake_count = zx_futex_wake->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_futex_wake->Input<zx_futex_t>("value_ptr", |
| std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| zx_futex_wake->Input<uint32_t>("wake_count", |
| std::make_unique<ArgumentAccess<uint32_t>>(wake_count)); |
| } |
| |
| { |
| Syscall* zx_futex_requeue = Add("zx_futex_requeue", SyscallReturnType::kStatus); |
| // Arguments |
| auto value_ptr = zx_futex_requeue->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto wake_count = zx_futex_requeue->Argument<uint32_t>(SyscallType::kUint32); |
| auto current_value = zx_futex_requeue->Argument<zx_futex_t>(SyscallType::kFutex); |
| auto requeue_ptr = zx_futex_requeue->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto requeue_count = zx_futex_requeue->Argument<uint32_t>(SyscallType::kUint32); |
| auto new_requeue_owner = zx_futex_requeue->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_futex_requeue->Input<zx_futex_t>("value_ptr", |
| std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| zx_futex_requeue->Input<uint32_t>("wake_count", |
| std::make_unique<ArgumentAccess<uint32_t>>(wake_count)); |
| zx_futex_requeue->Input<zx_futex_t>( |
| "current_value", std::make_unique<ArgumentAccess<zx_futex_t>>(current_value)); |
| zx_futex_requeue->Input<zx_futex_t>("requeue_ptr", |
| std::make_unique<ArgumentAccess<zx_futex_t>>(requeue_ptr)); |
| zx_futex_requeue->Input<uint32_t>("requeue_count", |
| std::make_unique<ArgumentAccess<uint32_t>>(requeue_count)); |
| zx_futex_requeue->Input<zx_handle_t>( |
| "new_requeue_owner", std::make_unique<ArgumentAccess<zx_handle_t>>(new_requeue_owner)); |
| } |
| |
| { |
| Syscall* zx_futex_wake_single_owner = |
| Add("zx_futex_wake_single_owner", SyscallReturnType::kStatus); |
| // Arguments |
| auto value_ptr = zx_futex_wake_single_owner->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| // Inputs |
| zx_futex_wake_single_owner->Input<zx_futex_t>( |
| "value_ptr", std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| } |
| |
| { |
| Syscall* zx_futex_requeue_single_owner = |
| Add("zx_futex_requeue_single_owner", SyscallReturnType::kStatus); |
| // Arguments |
| auto value_ptr = |
| zx_futex_requeue_single_owner->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto current_value = zx_futex_requeue_single_owner->Argument<zx_futex_t>(SyscallType::kFutex); |
| auto requeue_ptr = |
| zx_futex_requeue_single_owner->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto requeue_count = zx_futex_requeue_single_owner->Argument<uint32_t>(SyscallType::kUint32); |
| auto new_requeue_owner = |
| zx_futex_requeue_single_owner->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_futex_requeue_single_owner->Input<zx_futex_t>( |
| "value_ptr", std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| zx_futex_requeue_single_owner->Input<zx_futex_t>( |
| "current_value", std::make_unique<ArgumentAccess<zx_futex_t>>(current_value)); |
| zx_futex_requeue_single_owner->Input<zx_futex_t>( |
| "requeue_ptr", std::make_unique<ArgumentAccess<zx_futex_t>>(requeue_ptr)); |
| zx_futex_requeue_single_owner->Input<uint32_t>( |
| "requeue_count", std::make_unique<ArgumentAccess<uint32_t>>(requeue_count)); |
| zx_futex_requeue_single_owner->Input<zx_handle_t>( |
| "new_requeue_owner", std::make_unique<ArgumentAccess<zx_handle_t>>(new_requeue_owner)); |
| } |
| |
| { |
| Syscall* zx_futex_get_owner = Add("zx_futex_get_owner", SyscallReturnType::kStatus); |
| // Arguments |
| auto value_ptr = zx_futex_get_owner->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto koid = zx_futex_get_owner->PointerArgument<zx_koid_t>(SyscallType::kKoid); |
| // Inputs |
| zx_futex_get_owner->Input<zx_futex_t>("value_ptr", |
| std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| // Outputs |
| zx_futex_get_owner->Output<zx_koid_t>(ZX_OK, "koid", |
| std::make_unique<ArgumentAccess<zx_koid_t>>(koid)); |
| } |
| |
| { |
| Syscall* zx_futex_wake_handle_close_thread_exit = |
| Add("zx_futex_wake_handle_close_thread_exit", SyscallReturnType::kNoReturn); |
| // Arguments |
| auto value_ptr = |
| zx_futex_wake_handle_close_thread_exit->PointerArgument<zx_futex_t>(SyscallType::kFutex); |
| auto wake_count = |
| zx_futex_wake_handle_close_thread_exit->Argument<uint32_t>(SyscallType::kUint32); |
| auto new_value = zx_futex_wake_handle_close_thread_exit->Argument<int32_t>(SyscallType::kInt32); |
| auto close_handle = |
| zx_futex_wake_handle_close_thread_exit->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_futex_wake_handle_close_thread_exit->Input<zx_futex_t>( |
| "value_ptr", std::make_unique<ArgumentAccess<zx_futex_t>>(value_ptr)); |
| zx_futex_wake_handle_close_thread_exit->Input<uint32_t>( |
| "wake_count", std::make_unique<ArgumentAccess<uint32_t>>(wake_count)); |
| zx_futex_wake_handle_close_thread_exit->Input<int32_t>( |
| "new_value", std::make_unique<ArgumentAccess<int32_t>>(new_value)); |
| zx_futex_wake_handle_close_thread_exit->Input<zx_handle_t>( |
| "close_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(close_handle)); |
| } |
| |
| { |
| Syscall* zx_port_create = Add("zx_port_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_port_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_port_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_port_create->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_port_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_port_create->set_inference(&SyscallDecoderDispatcher::ZxPortCreate); |
| |
| zx_port_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_port_queue = Add("zx_port_queue", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_port_queue->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto packet = zx_port_queue->PointerArgument<zx_port_packet_t>(SyscallType::kStruct); |
| // Inputs |
| zx_port_queue->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_port_queue->InputObject<zx_port_packet_t>( |
| "packet", std::make_unique<ArgumentAccess<zx_port_packet_t>>(packet), |
| ZxPortPacket::GetClass()); |
| } |
| |
| { |
| Syscall* zx_port_wait = Add("zx_port_wait", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_port_wait->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto deadline = zx_port_wait->Argument<zx_time_t>(SyscallType::kTime); |
| auto packet = zx_port_wait->PointerArgument<zx_port_packet_t>(SyscallType::kStruct); |
| // Inputs |
| zx_port_wait->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_port_wait->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| // Outputs |
| zx_port_wait->OutputObject<zx_port_packet_t>( |
| ZX_OK, "packet", std::make_unique<ArgumentAccess<zx_port_packet_t>>(packet), |
| ZxPortPacket::GetClass()); |
| } |
| |
| { |
| Syscall* zx_port_cancel = Add("zx_port_cancel", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_port_cancel->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto source = zx_port_cancel->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto key = zx_port_cancel->Argument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_port_cancel->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_port_cancel->Input<zx_handle_t>("source", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(source)); |
| zx_port_cancel->Input<uint64_t>("key", std::make_unique<ArgumentAccess<uint64_t>>(key)); |
| } |
| |
| { |
| Syscall* zx_timer_create = Add("zx_timer_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_timer_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto clock_id = zx_timer_create->Argument<zx_clock_t>(SyscallType::kClock); |
| auto out = zx_timer_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_timer_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_timer_create->Input<zx_clock_t>("clock_id", |
| std::make_unique<ArgumentAccess<zx_clock_t>>(clock_id)); |
| // Outputs |
| zx_timer_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_timer_create->set_inference(&SyscallDecoderDispatcher::ZxTimerCreate); |
| |
| zx_timer_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_timer_set = Add("zx_timer_set", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_timer_set->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto deadline = zx_timer_set->Argument<zx_time_t>(SyscallType::kMonotonicTime); |
| auto slack = zx_timer_set->Argument<zx_duration_t>(SyscallType::kDuration); |
| // Inputs |
| zx_timer_set->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_timer_set->Input<zx_time_t>("deadline", |
| std::make_unique<ArgumentAccess<zx_time_t>>(deadline)); |
| zx_timer_set->Input<zx_duration_t>("slack", |
| std::make_unique<ArgumentAccess<zx_duration_t>>(slack)); |
| } |
| |
| { |
| Syscall* zx_timer_cancel = Add("zx_timer_cancel", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_timer_cancel->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_timer_cancel->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_vmo_create = Add("zx_vmo_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto size = zx_vmo_create->Argument<uint64_t>(SyscallType::kUint64); |
| auto options = zx_vmo_create->Argument<uint32_t>(SyscallType::kVmoCreationOption); |
| auto out = zx_vmo_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmo_create->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| zx_vmo_create->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_vmo_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_vmo_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_vmo_read = Add("zx_vmo_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto buffer = zx_vmo_read->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto offset = zx_vmo_read->Argument<uint64_t>(SyscallType::kUint64); |
| auto buffer_size = zx_vmo_read->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_vmo_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_read->Input<uint64_t>("offset", std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| // Outputs |
| zx_vmo_read->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_vmo_write = Add("zx_vmo_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto buffer = zx_vmo_write->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto offset = zx_vmo_write->Argument<uint64_t>(SyscallType::kUint64); |
| auto buffer_size = zx_vmo_write->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_vmo_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_write->Input<uint64_t>("offset", std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| zx_vmo_write->InputBuffer<uint8_t, uint8_t, size_t>( |
| "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_vmo_get_size = Add("zx_vmo_get_size", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_get_size->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto size = zx_vmo_get_size->PointerArgument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_vmo_get_size->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_vmo_get_size->Output<uint64_t>(ZX_OK, "size", |
| std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| } |
| |
| { |
| Syscall* zx_vmo_set_size = Add("zx_vmo_set_size", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_set_size->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto size = zx_vmo_set_size->Argument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_vmo_set_size->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_set_size->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| } |
| |
| { |
| Syscall* zx_vmo_op_range = Add("zx_vmo_op_range", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_op_range->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto op = zx_vmo_op_range->Argument<uint32_t>(SyscallType::kVmoOp); |
| auto offset = zx_vmo_op_range->Argument<uint64_t>(SyscallType::kUint64); |
| auto size = zx_vmo_op_range->Argument<uint64_t>(SyscallType::kUint64); |
| zx_vmo_op_range->PointerArgument<uint8_t>(SyscallType::kUint8); |
| zx_vmo_op_range->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_vmo_op_range->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_op_range->Input<uint32_t>("op", std::make_unique<ArgumentAccess<uint32_t>>(op)); |
| zx_vmo_op_range->Input<uint64_t>("offset", std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| zx_vmo_op_range->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| } |
| |
| { |
| Syscall* zx_vmo_create_child = Add("zx_vmo_create_child", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_create_child->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_vmo_create_child->Argument<uint32_t>(SyscallType::kVmoOption); |
| auto offset = zx_vmo_create_child->Argument<uint64_t>(SyscallType::kUint64); |
| auto size = zx_vmo_create_child->Argument<uint64_t>(SyscallType::kUint64); |
| auto out = zx_vmo_create_child->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmo_create_child->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_create_child->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_vmo_create_child->Input<uint64_t>("offset", |
| std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| zx_vmo_create_child->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| // Outputs |
| zx_vmo_create_child->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_vmo_create_child->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_vmo_set_cache_policy = Add("zx_vmo_set_cache_policy", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_set_cache_policy->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto cache_policy = zx_vmo_set_cache_policy->Argument<uint32_t>(SyscallType::kCachePolicy); |
| // Inputs |
| zx_vmo_set_cache_policy->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_set_cache_policy->Input<uint32_t>( |
| "cache_policy", std::make_unique<ArgumentAccess<uint32_t>>(cache_policy)); |
| } |
| |
| { |
| Syscall* zx_vmo_replace_as_executable = |
| Add("zx_vmo_replace_as_executable", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmo_replace_as_executable->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vmex = zx_vmo_replace_as_executable->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto out = zx_vmo_replace_as_executable->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmo_replace_as_executable->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmo_replace_as_executable->Input<zx_handle_t>( |
| "vmex", std::make_unique<ArgumentAccess<zx_handle_t>>(vmex)); |
| // Outputs |
| zx_vmo_replace_as_executable->Output<zx_handle_t>( |
| ZX_OK, "out", std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| } |
| |
| { |
| Syscall* zx_vmo_create_contiguous = Add("zx_vmo_create_contiguous", SyscallReturnType::kStatus); |
| // Arguments |
| auto bti = zx_vmo_create_contiguous->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto size = zx_vmo_create_contiguous->Argument<size_t>(SyscallType::kSize); |
| auto alignment_log2 = zx_vmo_create_contiguous->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_vmo_create_contiguous->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmo_create_contiguous->Input<zx_handle_t>( |
| "bti", std::make_unique<ArgumentAccess<zx_handle_t>>(bti)); |
| zx_vmo_create_contiguous->Input<size_t>("size", std::make_unique<ArgumentAccess<size_t>>(size)); |
| zx_vmo_create_contiguous->Input<uint32_t>( |
| "alignment_log2", std::make_unique<ArgumentAccess<uint32_t>>(alignment_log2)); |
| // Outputs |
| zx_vmo_create_contiguous->Output<zx_handle_t>( |
| ZX_OK, "out", std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_vmo_create_contiguous->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_vmo_create_physical = Add("zx_vmo_create_physical", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_vmo_create_physical->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto paddr = zx_vmo_create_physical->Argument<zx_paddr_t>(SyscallType::kPaddr); |
| auto size = zx_vmo_create_physical->Argument<size_t>(SyscallType::kSize); |
| auto out = zx_vmo_create_physical->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmo_create_physical->Input<zx_handle_t>( |
| "resource", std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_vmo_create_physical->Input<zx_paddr_t>("paddr", |
| std::make_unique<ArgumentAccess<zx_paddr_t>>(paddr)); |
| zx_vmo_create_physical->Input<size_t>("size", std::make_unique<ArgumentAccess<size_t>>(size)); |
| // Outputs |
| zx_vmo_create_physical->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_vmo_create_physical->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_vmar_allocate = Add("zx_vmar_allocate", SyscallReturnType::kStatus); |
| // Arguments |
| auto parent_vmar = zx_vmar_allocate->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_vmar_allocate->Argument<zx_vm_option_t>(SyscallType::kVmOption); |
| auto offset = zx_vmar_allocate->Argument<uint64_t>(SyscallType::kUint64); |
| auto size = zx_vmar_allocate->Argument<uint64_t>(SyscallType::kUint64); |
| auto child_vmar = zx_vmar_allocate->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto child_addr = zx_vmar_allocate->PointerArgument<zx_vaddr_t>(SyscallType::kVaddr); |
| // Inputs |
| zx_vmar_allocate->Input<zx_handle_t>( |
| "parent_vmar", std::make_unique<ArgumentAccess<zx_handle_t>>(parent_vmar)); |
| zx_vmar_allocate->Input<zx_vm_option_t>( |
| "options", std::make_unique<ArgumentAccess<zx_vm_option_t>>(options)); |
| zx_vmar_allocate->Input<uint64_t>("offset", std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| zx_vmar_allocate->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| // Outputs |
| zx_vmar_allocate->Output<zx_handle_t>( |
| ZX_OK, "child_vmar", std::make_unique<ArgumentAccess<zx_handle_t>>(child_vmar)); |
| zx_vmar_allocate->Output<zx_vaddr_t>(ZX_OK, "child_addr", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(child_addr)); |
| } |
| |
| { |
| Syscall* zx_vmar_destroy = Add("zx_vmar_destroy", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmar_destroy->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmar_destroy->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_vmar_map = Add("zx_vmar_map", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmar_map->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_vmar_map->Argument<zx_vm_option_t>(SyscallType::kVmOption); |
| auto vmar_offset = zx_vmar_map->Argument<uint64_t>(SyscallType::kUint64); |
| auto vmo = zx_vmar_map->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vmo_offset = zx_vmar_map->Argument<uint64_t>(SyscallType::kUint64); |
| auto len = zx_vmar_map->Argument<uint64_t>(SyscallType::kUint64); |
| auto mapped_addr = zx_vmar_map->PointerArgument<zx_vaddr_t>(SyscallType::kVaddr); |
| // Inputs |
| zx_vmar_map->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmar_map->Input<zx_vm_option_t>("options", |
| std::make_unique<ArgumentAccess<zx_vm_option_t>>(options)); |
| zx_vmar_map->Input<uint64_t>("vmar_offset", |
| std::make_unique<ArgumentAccess<uint64_t>>(vmar_offset)); |
| zx_vmar_map->Input<zx_handle_t>("vmo", std::make_unique<ArgumentAccess<zx_handle_t>>(vmo)); |
| zx_vmar_map->Input<uint64_t>("vmo_offset", |
| std::make_unique<ArgumentAccess<uint64_t>>(vmo_offset)); |
| zx_vmar_map->Input<uint64_t>("len", std::make_unique<ArgumentAccess<uint64_t>>(len)); |
| // Outputs |
| zx_vmar_map->Output<zx_vaddr_t>(ZX_OK, "mapped_addr", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(mapped_addr)); |
| } |
| |
| { |
| Syscall* zx_vmar_unmap = Add("zx_vmar_unmap", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmar_unmap->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto addr = zx_vmar_unmap->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto len = zx_vmar_unmap->Argument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_vmar_unmap->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmar_unmap->Input<zx_vaddr_t>("addr", std::make_unique<ArgumentAccess<zx_vaddr_t>>(addr)); |
| zx_vmar_unmap->Input<uint64_t>("len", std::make_unique<ArgumentAccess<uint64_t>>(len)); |
| } |
| |
| { |
| Syscall* zx_vmar_protect = Add("zx_vmar_protect", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vmar_protect->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_vmar_protect->Argument<zx_vm_option_t>(SyscallType::kVmOption); |
| auto addr = zx_vmar_protect->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto len = zx_vmar_protect->Argument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_vmar_protect->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vmar_protect->Input<zx_vm_option_t>( |
| "options", std::make_unique<ArgumentAccess<zx_vm_option_t>>(options)); |
| zx_vmar_protect->Input<zx_vaddr_t>("addr", std::make_unique<ArgumentAccess<zx_vaddr_t>>(addr)); |
| zx_vmar_protect->Input<uint64_t>("len", std::make_unique<ArgumentAccess<uint64_t>>(len)); |
| } |
| |
| { |
| Syscall* zx_vmar_unmap_handle_close_thread_exit = |
| Add("zx_vmar_unmap_handle_close_thread_exit", SyscallReturnType::kStatus); |
| // Arguments |
| auto vmar_handle = |
| zx_vmar_unmap_handle_close_thread_exit->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto addr = zx_vmar_unmap_handle_close_thread_exit->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto size = zx_vmar_unmap_handle_close_thread_exit->Argument<size_t>(SyscallType::kSize); |
| auto close_handle = |
| zx_vmar_unmap_handle_close_thread_exit->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vmar_unmap_handle_close_thread_exit->Input<zx_handle_t>( |
| "vmar_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(vmar_handle)); |
| zx_vmar_unmap_handle_close_thread_exit->Input<zx_vaddr_t>( |
| "addr", std::make_unique<ArgumentAccess<zx_vaddr_t>>(addr)); |
| zx_vmar_unmap_handle_close_thread_exit->Input<size_t>( |
| "size", std::make_unique<ArgumentAccess<size_t>>(size)); |
| zx_vmar_unmap_handle_close_thread_exit->Input<zx_handle_t>( |
| "close_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(close_handle)); |
| } |
| |
| { |
| Syscall* zx_cprng_draw = Add("zx_cprng_draw", SyscallReturnType::kVoid); |
| // Arguments |
| auto buffer = zx_cprng_draw->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto buffer_size = zx_cprng_draw->Argument<size_t>(SyscallType::kSize); |
| // Outputs |
| zx_cprng_draw->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_cprng_add_entropy = Add("zx_cprng_add_entropy", SyscallReturnType::kStatus); |
| // Arguments |
| auto buffer = zx_cprng_add_entropy->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto buffer_size = zx_cprng_add_entropy->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_cprng_add_entropy->InputBuffer<uint8_t, uint8_t, size_t>( |
| "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_fifo_create = Add("zx_fifo_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto elem_count = zx_fifo_create->Argument<size_t>(SyscallType::kSize); |
| auto elem_size = zx_fifo_create->Argument<size_t>(SyscallType::kSize); |
| auto options = zx_fifo_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out0 = zx_fifo_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto out1 = zx_fifo_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_fifo_create->Input<size_t>("elem_count", |
| std::make_unique<ArgumentAccess<size_t>>(elem_count)); |
| zx_fifo_create->Input<size_t>("elem_size", std::make_unique<ArgumentAccess<size_t>>(elem_size)); |
| zx_fifo_create->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_fifo_create->Output<zx_handle_t>(ZX_OK, "out0", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out0)); |
| zx_fifo_create->Output<zx_handle_t>(ZX_OK, "out1", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out1)); |
| |
| zx_fifo_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out0 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out0", /*invoked=*/false)); |
| FX_DCHECK(out0 != nullptr); |
| out0->AddCreationEvent(event); |
| auto out1 = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out1", /*invoked=*/false)); |
| FX_DCHECK(out1 != nullptr); |
| out1->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_fifo_read = Add("zx_fifo_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_fifo_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto elem_size = zx_fifo_read->Argument<size_t>(SyscallType::kSize); |
| auto data = zx_fifo_read->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto count = zx_fifo_read->Argument<size_t>(SyscallType::kSize); |
| auto actual_count = zx_fifo_read->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_fifo_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_fifo_read->Input<size_t>("elem_size", std::make_unique<ArgumentAccess<size_t>>(elem_size)); |
| zx_fifo_read->Input<size_t>("count", std::make_unique<ArgumentAccess<size_t>>(count)); |
| // Outputs |
| zx_fifo_read->OutputActualAndRequested<size_t>( |
| ZX_OK, "actual", std::make_unique<ArgumentAccess<size_t>>(actual_count), |
| std::make_unique<ArgumentAccess<size_t>>(count)); |
| zx_fifo_read->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "data", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(data), |
| std::make_unique<ArgumentAccess<size_t>>(elem_size), |
| std::make_unique<ArgumentAccess<size_t>>(actual_count)); |
| } |
| |
| { |
| Syscall* zx_fifo_write = Add("zx_fifo_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_fifo_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto elem_size = zx_fifo_write->Argument<size_t>(SyscallType::kSize); |
| auto data = zx_fifo_write->PointerArgument<uint8_t>(SyscallType::kUint8Hexa); |
| auto count = zx_fifo_write->Argument<size_t>(SyscallType::kSize); |
| auto actual_count = zx_fifo_write->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_fifo_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_fifo_write->Input<size_t>("elem_size", std::make_unique<ArgumentAccess<size_t>>(elem_size)); |
| zx_fifo_write->Input<size_t>("count", std::make_unique<ArgumentAccess<size_t>>(count)); |
| zx_fifo_write->InputBuffer<uint8_t, uint8_t, size_t>( |
| "data", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(data), |
| std::make_unique<ArgumentAccess<size_t>>(elem_size), |
| std::make_unique<ArgumentAccess<size_t>>(count)); |
| // Outputs |
| zx_fifo_write->OutputActualAndRequested<size_t>( |
| ZX_OK, "actual", std::make_unique<ArgumentAccess<size_t>>(actual_count), |
| std::make_unique<ArgumentAccess<size_t>>(count)); |
| } |
| |
| { |
| Syscall* zx_profile_create = Add("zx_profile_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto root_job = zx_profile_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_profile_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto profile = zx_profile_create->PointerArgument<zx_profile_info_t>(SyscallType::kStruct); |
| auto out = zx_profile_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_profile_create->Input<zx_handle_t>("root_job", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(root_job)); |
| zx_profile_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_profile_create->InputObject<zx_profile_info_t>( |
| "info", std::make_unique<ArgumentAccess<zx_profile_info_t>>(profile), |
| ZxProfileInfo::GetClass()); |
| // Outputs |
| zx_profile_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_profile_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_debuglog_create = Add("zx_debuglog_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_debuglog_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_debuglog_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_debuglog_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_debuglog_create->Input<zx_handle_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_debuglog_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_debuglog_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_debuglog_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_debuglog_write = Add("zx_debuglog_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_debuglog_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_debuglog_write->Argument<uint32_t>(SyscallType::kUint32); |
| auto buffer = zx_debuglog_write->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_debuglog_write->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_debuglog_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_debuglog_write->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_debuglog_write->InputBuffer<uint8_t, uint8_t, size_t>( |
| "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_debuglog_read = Add("zx_debuglog_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_debuglog_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_debuglog_read->Argument<uint32_t>(SyscallType::kUint32); |
| auto buffer = zx_debuglog_read->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto buffer_size = zx_debuglog_read->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_debuglog_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_debuglog_read->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_debuglog_read->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "buffer", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_ktrace_read = Add("zx_ktrace_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_ktrace_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto data = zx_ktrace_read->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto offset = zx_ktrace_read->Argument<uint32_t>(SyscallType::kUint32); |
| auto data_size = zx_ktrace_read->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_ktrace_read->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_ktrace_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_ktrace_read->Input<uint32_t>("offset", std::make_unique<ArgumentAccess<uint32_t>>(offset)); |
| // Outputs |
| zx_ktrace_read->OutputActualAndRequested<size_t>( |
| ZX_OK, "actual", std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(data_size)); |
| zx_ktrace_read->OutputBuffer<uint8_t, uint8_t, size_t>( |
| ZX_OK, "data", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(data), |
| std::make_unique<ArgumentAccess<size_t>>(actual)); |
| } |
| |
| { |
| Syscall* zx_ktrace_control = Add("zx_ktrace_control", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_ktrace_control->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto action = zx_ktrace_control->Argument<uint32_t>(SyscallType::kKtraceControlAction); |
| auto options = zx_ktrace_control->Argument<uint32_t>(SyscallType::kUint32); |
| auto ptr = zx_ktrace_control->PointerArgument<char>(SyscallType::kChar); |
| // Conditional field Ids |
| const uint8_t kZxKtraceControl_KTRACE_ACTION_NEW_PROBE = 1; |
| // Inputs |
| zx_ktrace_control->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_ktrace_control->Input<uint32_t>("action", |
| std::make_unique<ArgumentAccess<uint32_t>>(action)); |
| zx_ktrace_control->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| constexpr uint32_t KTRACE_ACTION_NEW_PROBE = 4; |
| zx_ktrace_control |
| ->InputFixedSizeString("ptr", std::make_unique<ArgumentAccess<char>>(ptr), ZX_MAX_NAME_LEN) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(action), |
| KTRACE_ACTION_NEW_PROBE) |
| ->SetId(kZxKtraceControl_KTRACE_ACTION_NEW_PROBE); |
| } |
| |
| { |
| Syscall* zx_ktrace_write = Add("zx_ktrace_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_ktrace_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto id = zx_ktrace_write->Argument<uint32_t>(SyscallType::kUint32); |
| auto arg0 = zx_ktrace_write->Argument<uint32_t>(SyscallType::kUint32); |
| auto arg1 = zx_ktrace_write->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_ktrace_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_ktrace_write->Input<uint32_t>("id", std::make_unique<ArgumentAccess<uint32_t>>(id)); |
| zx_ktrace_write->Input<uint32_t>("arg0", std::make_unique<ArgumentAccess<uint32_t>>(arg0)); |
| zx_ktrace_write->Input<uint32_t>("arg1", std::make_unique<ArgumentAccess<uint32_t>>(arg1)); |
| } |
| |
| { |
| Syscall* zx_mtrace_control = Add("zx_mtrace_control", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_mtrace_control->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_mtrace_control->Argument<uint32_t>(SyscallType::kUint32); |
| auto action = zx_mtrace_control->Argument<uint32_t>(SyscallType::kUint32); |
| auto options = zx_mtrace_control->Argument<uint32_t>(SyscallType::kUint32); |
| auto ptr = zx_mtrace_control->PointerArgument<uint8_t>(SyscallType::kUint8); |
| auto ptr_size = zx_mtrace_control->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_mtrace_control->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_mtrace_control->Input<uint32_t>("kind", std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| zx_mtrace_control->Input<uint32_t>("action", |
| std::make_unique<ArgumentAccess<uint32_t>>(action)); |
| zx_mtrace_control->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_mtrace_control->InputBuffer<uint8_t, uint8_t, size_t>( |
| "ptr", SyscallType::kUint8Hexa, std::make_unique<ArgumentAccess<uint8_t>>(ptr), |
| std::make_unique<ArgumentAccess<size_t>>(ptr_size)); |
| } |
| |
| { |
| Syscall* zx_debug_read = Add("zx_debug_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_debug_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto buffer = zx_debug_read->PointerArgument<char>(SyscallType::kChar); |
| auto buffer_size = zx_debug_read->Argument<size_t>(SyscallType::kSize); |
| auto actual = zx_debug_read->PointerArgument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_debug_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_debug_read->OutputActualAndRequested<size_t>( |
| ZX_OK, "actual", std::make_unique<ArgumentAccess<size_t>>(actual), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| zx_debug_read->OutputString<char>(ZX_OK, "buffer", |
| std::make_unique<ArgumentAccess<char>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(actual)); |
| } |
| |
| { |
| Syscall* zx_debug_write = Add("zx_debug_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto buffer = zx_debug_write->PointerArgument<char>(SyscallType::kChar); |
| auto buffer_size = zx_debug_write->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_debug_write->InputString<char>("buffer", std::make_unique<ArgumentAccess<char>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_debug_send_command = Add("zx_debug_send_command", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_debug_send_command->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto buffer = zx_debug_send_command->PointerArgument<char>(SyscallType::kChar); |
| auto buffer_size = zx_debug_send_command->Argument<size_t>(SyscallType::kSize); |
| // Inputs |
| zx_debug_send_command->Input<zx_handle_t>( |
| "resource", std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_debug_send_command->InputString<char>("buffer", |
| std::make_unique<ArgumentAccess<char>>(buffer), |
| std::make_unique<ArgumentAccess<size_t>>(buffer_size)); |
| } |
| |
| { |
| Syscall* zx_interrupt_create = Add("zx_interrupt_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto src_obj = zx_interrupt_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto src_num = zx_interrupt_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto options = zx_interrupt_create->Argument<uint32_t>(SyscallType::kInterruptFlags); |
| auto out_handle = zx_interrupt_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_interrupt_create->Input<zx_handle_t>("src_obj", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(src_obj)); |
| zx_interrupt_create->Input<uint32_t>("src_num", |
| std::make_unique<ArgumentAccess<uint32_t>>(src_num)); |
| zx_interrupt_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_interrupt_create->Output<zx_handle_t>( |
| ZX_OK, "out_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(out_handle)); |
| |
| zx_interrupt_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out_handle = event->GetHandleInfo( |
| event->syscall()->SearchInlineMember("out_handle", /*invoked=*/false)); |
| FX_DCHECK(out_handle != nullptr); |
| out_handle->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_interrupt_bind = Add("zx_interrupt_bind", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_interrupt_bind->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto port_handle = zx_interrupt_bind->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto key = zx_interrupt_bind->Argument<uint64_t>(SyscallType::kUint64); |
| auto options = zx_interrupt_bind->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_interrupt_bind->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_interrupt_bind->Input<zx_handle_t>( |
| "port_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(port_handle)); |
| zx_interrupt_bind->Input<uint64_t>("key", std::make_unique<ArgumentAccess<uint64_t>>(key)); |
| zx_interrupt_bind->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| } |
| |
| { |
| Syscall* zx_interrupt_wait = Add("zx_interrupt_wait", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_interrupt_wait->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto out_timestamp = zx_interrupt_wait->PointerArgument<zx_time_t>(SyscallType::kMonotonicTime); |
| // Inputs |
| zx_interrupt_wait->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_interrupt_wait->Output<zx_time_t>( |
| ZX_OK, "out_timestamp", std::make_unique<ArgumentAccess<zx_time_t>>(out_timestamp)); |
| } |
| |
| { |
| Syscall* zx_interrupt_destroy = Add("zx_interrupt_destroy", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_interrupt_destroy->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_interrupt_destroy->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_interrupt_ack = Add("zx_interrupt_ack", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_interrupt_ack->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_interrupt_ack->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_interrupt_trigger = Add("zx_interrupt_trigger", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_interrupt_trigger->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_interrupt_trigger->Argument<uint32_t>(SyscallType::kUint32); |
| auto timestamp = zx_interrupt_trigger->Argument<zx_time_t>(SyscallType::kMonotonicTime); |
| // Inputs |
| zx_interrupt_trigger->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_interrupt_trigger->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_interrupt_trigger->Input<zx_time_t>("timestamp", |
| std::make_unique<ArgumentAccess<zx_time_t>>(timestamp)); |
| } |
| |
| { |
| Syscall* zx_interrupt_bind_vcpu = Add("zx_interrupt_bind_vcpu", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_interrupt_bind_vcpu->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vcpu = zx_interrupt_bind_vcpu->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_interrupt_bind_vcpu->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_interrupt_bind_vcpu->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_interrupt_bind_vcpu->Input<zx_handle_t>("vcpu", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(vcpu)); |
| zx_interrupt_bind_vcpu->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| } |
| |
| { |
| Syscall* zx_ioports_request = Add("zx_ioports_request", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_ioports_request->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto io_addr = zx_ioports_request->Argument<uint16_t>(SyscallType::kUint16Hexa); |
| auto len = zx_ioports_request->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_ioports_request->Input<zx_handle_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_ioports_request->Input<uint16_t>("io_addr", |
| std::make_unique<ArgumentAccess<uint16_t>>(io_addr)); |
| zx_ioports_request->Input<uint32_t>("len", std::make_unique<ArgumentAccess<uint32_t>>(len)); |
| } |
| |
| { |
| Syscall* zx_ioports_release = Add("zx_ioports_release", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_ioports_release->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto io_addr = zx_ioports_release->Argument<uint16_t>(SyscallType::kUint16Hexa); |
| auto len = zx_ioports_release->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_ioports_release->Input<zx_handle_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_ioports_release->Input<uint16_t>("io_addr", |
| std::make_unique<ArgumentAccess<uint16_t>>(io_addr)); |
| zx_ioports_release->Input<uint32_t>("len", std::make_unique<ArgumentAccess<uint32_t>>(len)); |
| } |
| |
| { |
| Syscall* zx_iommu_create = Add("zx_iommu_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_iommu_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto type = zx_iommu_create->Argument<uint32_t>(SyscallType::kIommuType); |
| auto desc = zx_iommu_create->PointerArgument<uint8_t>(SyscallType::kUint8); |
| zx_iommu_create->Argument<size_t>(SyscallType::kSize); |
| auto out = zx_iommu_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Conditional field Ids |
| const uint8_t kZxIommuCreate_ZX_IOMMU_TYPE_INTEL = 1; |
| // Inputs |
| zx_iommu_create->Input<zx_handle_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_iommu_create->Input<uint32_t>("type", std::make_unique<ArgumentAccess<uint32_t>>(type)); |
| zx_iommu_create |
| ->InputObject<zx_iommu_desc_intel_t>( |
| "desc", std::make_unique<ArgumentAccess<uint8_t>>(desc), ZxIommuDescIntel::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(type), |
| ZX_IOMMU_TYPE_INTEL) |
| ->SetId(kZxIommuCreate_ZX_IOMMU_TYPE_INTEL); |
| // Outputs |
| zx_iommu_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_iommu_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_bti_create = Add("zx_bti_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto iommu = zx_bti_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_bti_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto bti_id = zx_bti_create->Argument<uint64_t>(SyscallType::kUint64); |
| auto out = zx_bti_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_bti_create->Input<zx_handle_t>("iommu", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(iommu)); |
| zx_bti_create->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_bti_create->Input<uint64_t>("bti_id", std::make_unique<ArgumentAccess<uint64_t>>(bti_id)); |
| // Outputs |
| zx_bti_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_bti_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_bti_pin = Add("zx_bti_pin", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_bti_pin->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_bti_pin->Argument<uint32_t>(SyscallType::kBtiPerm); |
| auto vmo = zx_bti_pin->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto offset = zx_bti_pin->Argument<uint64_t>(SyscallType::kUint64); |
| auto size = zx_bti_pin->Argument<uint64_t>(SyscallType::kUint64); |
| auto addrs = zx_bti_pin->PointerArgument<zx_paddr_t>(SyscallType::kPaddr); |
| auto addrs_count = zx_bti_pin->Argument<size_t>(SyscallType::kSize); |
| auto pmt = zx_bti_pin->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_bti_pin->Input<zx_handle_t>("handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_bti_pin->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_bti_pin->Input<zx_handle_t>("vmo", std::make_unique<ArgumentAccess<zx_handle_t>>(vmo)); |
| zx_bti_pin->Input<uint64_t>("offset", std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| zx_bti_pin->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| // Outputs |
| zx_bti_pin->OutputBuffer<zx_paddr_t, zx_paddr_t, size_t>( |
| ZX_OK, "addrs", SyscallType::kPaddr, std::make_unique<ArgumentAccess<zx_paddr_t>>(addrs), |
| std::make_unique<ArgumentAccess<size_t>>(addrs_count)); |
| zx_bti_pin->Output<zx_handle_t>(ZX_OK, "pmt", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(pmt)); |
| } |
| |
| { |
| Syscall* zx_bti_release_quarantine = |
| Add("zx_bti_release_quarantine", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_bti_release_quarantine->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_bti_release_quarantine->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_pmt_unpin = Add("zx_pmt_unpin", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pmt_unpin->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pmt_unpin->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_framebuffer_get_info = Add("zx_framebuffer_get_info", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_framebuffer_get_info->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto format = zx_framebuffer_get_info->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto width = zx_framebuffer_get_info->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto height = zx_framebuffer_get_info->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto stride = zx_framebuffer_get_info->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_framebuffer_get_info->Input<zx_handle_t>( |
| "resource", std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| // Outputs |
| zx_framebuffer_get_info->Output<uint32_t>(ZX_OK, "format", |
| std::make_unique<ArgumentAccess<uint32_t>>(format)); |
| zx_framebuffer_get_info->Output<uint32_t>(ZX_OK, "width", |
| std::make_unique<ArgumentAccess<uint32_t>>(width)); |
| zx_framebuffer_get_info->Output<uint32_t>(ZX_OK, "height", |
| std::make_unique<ArgumentAccess<uint32_t>>(height)); |
| zx_framebuffer_get_info->Output<uint32_t>(ZX_OK, "stride", |
| std::make_unique<ArgumentAccess<uint32_t>>(stride)); |
| } |
| |
| { |
| Syscall* zx_framebuffer_set_range = Add("zx_framebuffer_set_range", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_framebuffer_set_range->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vmo = zx_framebuffer_set_range->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto len = zx_framebuffer_set_range->Argument<uint32_t>(SyscallType::kUint32); |
| auto format = zx_framebuffer_set_range->Argument<uint32_t>(SyscallType::kUint32); |
| auto width = zx_framebuffer_set_range->Argument<uint32_t>(SyscallType::kUint32); |
| auto height = zx_framebuffer_set_range->Argument<uint32_t>(SyscallType::kUint32); |
| auto stride = zx_framebuffer_set_range->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_framebuffer_set_range->Input<zx_handle_t>( |
| "resource", std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_framebuffer_set_range->Input<zx_handle_t>( |
| "vmo", std::make_unique<ArgumentAccess<zx_handle_t>>(vmo)); |
| zx_framebuffer_set_range->Input<uint32_t>("len", |
| std::make_unique<ArgumentAccess<uint32_t>>(len)); |
| zx_framebuffer_set_range->Input<uint32_t>("format", |
| std::make_unique<ArgumentAccess<uint32_t>>(format)); |
| zx_framebuffer_set_range->Input<uint32_t>("width", |
| std::make_unique<ArgumentAccess<uint32_t>>(width)); |
| zx_framebuffer_set_range->Input<uint32_t>("height", |
| std::make_unique<ArgumentAccess<uint32_t>>(height)); |
| zx_framebuffer_set_range->Input<uint32_t>("stride", |
| std::make_unique<ArgumentAccess<uint32_t>>(stride)); |
| } |
| |
| { |
| Syscall* zx_pci_get_nth_device = Add("zx_pci_get_nth_device", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_get_nth_device->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto index = zx_pci_get_nth_device->Argument<uint32_t>(SyscallType::kUint32); |
| auto out_info = |
| zx_pci_get_nth_device->PointerArgument<zx_pcie_device_info_t>(SyscallType::kStruct); |
| auto out_handle = zx_pci_get_nth_device->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pci_get_nth_device->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_get_nth_device->Input<uint32_t>("index", |
| std::make_unique<ArgumentAccess<uint32_t>>(index)); |
| // Outputs |
| zx_pci_get_nth_device->InputObject<zx_pcie_device_info_t>( |
| "out_info", std::make_unique<ArgumentAccess<zx_pcie_device_info_t>>(out_info), |
| ZxPcieDeviceInfo::GetClass()); |
| zx_pci_get_nth_device->Output<zx_handle_t>( |
| ZX_OK, "out_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(out_handle)); |
| } |
| |
| { |
| Syscall* zx_pci_enable_bus_master = Add("zx_pci_enable_bus_master", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_enable_bus_master->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto enable = zx_pci_enable_bus_master->Argument<bool>(SyscallType::kBool); |
| // Inputs |
| zx_pci_enable_bus_master->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_enable_bus_master->Input<bool>("enable", std::make_unique<ArgumentAccess<bool>>(enable)); |
| } |
| |
| { |
| Syscall* zx_pci_reset_device = Add("zx_pci_reset_device", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_reset_device->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pci_reset_device->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| } |
| |
| { |
| Syscall* zx_pci_config_read = Add("zx_pci_config_read", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_config_read->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto offset = zx_pci_config_read->Argument<uint16_t>(SyscallType::kUint16); |
| auto width = zx_pci_config_read->Argument<size_t>(SyscallType::kSize); |
| auto out_val = zx_pci_config_read->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_pci_config_read->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_config_read->Input<uint16_t>("offset", |
| std::make_unique<ArgumentAccess<uint16_t>>(offset)); |
| zx_pci_config_read->Input<size_t>("width", std::make_unique<ArgumentAccess<size_t>>(width)); |
| // Outputs |
| zx_pci_config_read->Output<uint32_t>(ZX_OK, "out_val", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out_val)); |
| } |
| |
| { |
| Syscall* zx_pci_config_write = Add("zx_pci_config_write", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_config_write->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto offset = zx_pci_config_write->Argument<uint16_t>(SyscallType::kUint16); |
| auto width = zx_pci_config_write->Argument<size_t>(SyscallType::kSize); |
| auto val = zx_pci_config_write->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_pci_config_write->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_config_write->Input<uint16_t>("offset", |
| std::make_unique<ArgumentAccess<uint16_t>>(offset)); |
| zx_pci_config_write->Input<size_t>("width", std::make_unique<ArgumentAccess<size_t>>(width)); |
| zx_pci_config_write->Input<uint32_t>("val", std::make_unique<ArgumentAccess<uint32_t>>(val)); |
| } |
| |
| { |
| Syscall* zx_pci_cfg_pio_rw = Add("zx_pci_cfg_pio_rw", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_cfg_pio_rw->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto bus = zx_pci_cfg_pio_rw->Argument<uint8_t>(SyscallType::kUint8); |
| auto dev = zx_pci_cfg_pio_rw->Argument<uint8_t>(SyscallType::kUint8); |
| auto func = zx_pci_cfg_pio_rw->Argument<uint8_t>(SyscallType::kUint8); |
| auto offset = zx_pci_cfg_pio_rw->Argument<uint8_t>(SyscallType::kUint8); |
| auto val = zx_pci_cfg_pio_rw->PointerArgument<uint32_t>(SyscallType::kUint32); |
| auto width = zx_pci_cfg_pio_rw->Argument<size_t>(SyscallType::kSize); |
| auto write = zx_pci_cfg_pio_rw->Argument<bool>(SyscallType::kBool); |
| // Conditional field Ids |
| const uint8_t kZxPciCfgPioRw_true = 1; |
| const uint8_t kZxPciCfgPioRw_false = 2; |
| // Inputs |
| zx_pci_cfg_pio_rw->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_cfg_pio_rw->Input<uint8_t>("bus", std::make_unique<ArgumentAccess<uint8_t>>(bus)); |
| zx_pci_cfg_pio_rw->Input<uint8_t>("dev", std::make_unique<ArgumentAccess<uint8_t>>(dev)); |
| zx_pci_cfg_pio_rw->Input<uint8_t>("func", std::make_unique<ArgumentAccess<uint8_t>>(func)); |
| zx_pci_cfg_pio_rw->Input<uint8_t>("offset", std::make_unique<ArgumentAccess<uint8_t>>(offset)); |
| zx_pci_cfg_pio_rw->Input<size_t>("width", std::make_unique<ArgumentAccess<size_t>>(width)); |
| zx_pci_cfg_pio_rw->Input<uint32_t>("val", std::make_unique<ArgumentAccess<uint32_t>>(val)) |
| ->DisplayIfEqual<bool>(std::make_unique<ArgumentAccess<bool>>(write), true) |
| ->SetId(kZxPciCfgPioRw_true); |
| zx_pci_cfg_pio_rw->Input<bool>("write", std::make_unique<ArgumentAccess<bool>>(write)); |
| // Outputs |
| zx_pci_cfg_pio_rw |
| ->Output<uint32_t>(ZX_OK, "val", std::make_unique<ArgumentAccess<uint32_t>>(val)) |
| ->DisplayIfEqual<bool>(std::make_unique<ArgumentAccess<bool>>(write), false) |
| ->SetId(kZxPciCfgPioRw_false); |
| } |
| |
| { |
| Syscall* zx_pci_get_bar = Add("zx_pci_get_bar", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_get_bar->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto bar_num = zx_pci_get_bar->Argument<uint32_t>(SyscallType::kUint32); |
| auto out_bar = zx_pci_get_bar->PointerArgument<zx_pci_bar_t>(SyscallType::kStruct); |
| auto out_handle = zx_pci_get_bar->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pci_get_bar->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_get_bar->Input<uint32_t>("bar_num", std::make_unique<ArgumentAccess<uint32_t>>(bar_num)); |
| // Outputs |
| zx_pci_get_bar->OutputObject<zx_pci_bar_t>( |
| ZX_OK, "out_bar", std::make_unique<ArgumentAccess<zx_pci_bar_t>>(out_bar), |
| ZxPciBar::GetClass()); |
| zx_pci_get_bar->Output<zx_handle_t>(ZX_OK, "out_handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out_handle)); |
| } |
| |
| { |
| Syscall* zx_pci_map_interrupt = Add("zx_pci_map_interrupt", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_map_interrupt->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto which_irq = zx_pci_map_interrupt->Argument<int32_t>(SyscallType::kInt32); |
| auto out_handle = zx_pci_map_interrupt->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pci_map_interrupt->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_map_interrupt->Input<int32_t>("which_irq", |
| std::make_unique<ArgumentAccess<int32_t>>(which_irq)); |
| // Outputs |
| zx_pci_map_interrupt->Output<zx_handle_t>( |
| ZX_OK, "out_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(out_handle)); |
| } |
| |
| { |
| Syscall* zx_pci_query_irq_mode = Add("zx_pci_query_irq_mode", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_query_irq_mode->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto mode = zx_pci_query_irq_mode->Argument<uint32_t>(SyscallType::kUint32); |
| auto out_max_irqs = zx_pci_query_irq_mode->PointerArgument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_pci_query_irq_mode->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_query_irq_mode->Input<uint32_t>("mode", |
| std::make_unique<ArgumentAccess<uint32_t>>(mode)); |
| // Outputs |
| zx_pci_query_irq_mode->Output<uint32_t>( |
| ZX_OK, "out_max_irqs", std::make_unique<ArgumentAccess<uint32_t>>(out_max_irqs)); |
| } |
| |
| { |
| Syscall* zx_pci_set_irq_mode = Add("zx_pci_set_irq_mode", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_set_irq_mode->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto mode = zx_pci_set_irq_mode->Argument<uint32_t>(SyscallType::kUint32); |
| auto requested_irq_count = zx_pci_set_irq_mode->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_pci_set_irq_mode->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_set_irq_mode->Input<uint32_t>("mode", std::make_unique<ArgumentAccess<uint32_t>>(mode)); |
| zx_pci_set_irq_mode->Input<uint32_t>( |
| "requested_irq_count", std::make_unique<ArgumentAccess<uint32_t>>(requested_irq_count)); |
| } |
| |
| { |
| Syscall* zx_pci_init = Add("zx_pci_init", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_init->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto init_buf = zx_pci_init->PointerArgument<zx_pci_init_arg_t>(SyscallType::kStruct); |
| auto len = zx_pci_init->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_pci_init->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_init->InputObject<zx_pci_init_arg_t, uint32_t>( |
| "init_buf", std::make_unique<ArgumentAccess<zx_pci_init_arg_t>>(init_buf), |
| std::make_unique<ArgumentAccess<uint32_t>>(len), ZxPciInitArg::GetClass()); |
| zx_pci_init->Input<uint32_t>("len", std::make_unique<ArgumentAccess<uint32_t>>(len)); |
| } |
| |
| { |
| Syscall* zx_pci_add_subtract_io_range = |
| Add("zx_pci_add_subtract_io_range", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pci_add_subtract_io_range->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto mmio = zx_pci_add_subtract_io_range->Argument<bool>(SyscallType::kBool); |
| auto base = zx_pci_add_subtract_io_range->Argument<uint64_t>(SyscallType::kUint64); |
| auto len = zx_pci_add_subtract_io_range->Argument<uint64_t>(SyscallType::kUint64); |
| auto add = zx_pci_add_subtract_io_range->Argument<bool>(SyscallType::kBool); |
| // Inputs |
| zx_pci_add_subtract_io_range->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_pci_add_subtract_io_range->Input<bool>("mmio", std::make_unique<ArgumentAccess<bool>>(mmio)); |
| zx_pci_add_subtract_io_range->Input<uint64_t>("base", |
| std::make_unique<ArgumentAccess<uint64_t>>(base)); |
| zx_pci_add_subtract_io_range->Input<uint64_t>("len", |
| std::make_unique<ArgumentAccess<uint64_t>>(len)); |
| zx_pci_add_subtract_io_range->Input<bool>("add", std::make_unique<ArgumentAccess<bool>>(add)); |
| } |
| |
| { |
| Syscall* zx_pc_firmware_tables = Add("zx_pc_firmware_tables", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_pc_firmware_tables->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto acpi_rsdp = zx_pc_firmware_tables->PointerArgument<zx_paddr_t>(SyscallType::kPaddr); |
| auto smbios = zx_pc_firmware_tables->PointerArgument<zx_paddr_t>(SyscallType::kPaddr); |
| // Inputs |
| zx_pc_firmware_tables->Input<zx_handle_t>( |
| "handle", std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_pc_firmware_tables->Output<zx_paddr_t>( |
| ZX_OK, "acpi_rsdp", std::make_unique<ArgumentAccess<zx_paddr_t>>(acpi_rsdp)); |
| zx_pc_firmware_tables->Output<zx_paddr_t>(ZX_OK, "smbios", |
| std::make_unique<ArgumentAccess<zx_paddr_t>>(smbios)); |
| } |
| |
| { |
| Syscall* zx_smc_call = Add("zx_smc_call", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_smc_call->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto parameters = zx_smc_call->PointerArgument<zx_smc_parameters_t>(SyscallType::kStruct); |
| auto out_smc_result = zx_smc_call->PointerArgument<zx_smc_result_t>(SyscallType::kStruct); |
| // Inputs |
| zx_smc_call->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_smc_call->InputObject<zx_smc_parameters_t>( |
| "parameters", std::make_unique<ArgumentAccess<zx_smc_parameters_t>>(parameters), |
| ZxSmcParameters::GetClass()); |
| // Outputs |
| zx_smc_call->OutputObject<zx_smc_result_t>( |
| ZX_OK, "out_smc_result", std::make_unique<ArgumentAccess<zx_smc_result_t>>(out_smc_result), |
| ZxSmcResult::GetClass()); |
| } |
| |
| { |
| Syscall* zx_resource_create = Add("zx_resource_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto parent_rsrc = zx_resource_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_resource_create->Argument<uint32_t>(SyscallType::kRsrcKind); |
| auto base = zx_resource_create->Argument<uint64_t>(SyscallType::kUint64); |
| auto size = zx_resource_create->Argument<size_t>(SyscallType::kSize); |
| auto name = zx_resource_create->PointerArgument<char>(SyscallType::kChar); |
| auto name_size = zx_resource_create->Argument<size_t>(SyscallType::kSize); |
| auto resource_out = zx_resource_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_resource_create->Input<zx_handle_t>( |
| "parent_rsrc", std::make_unique<ArgumentAccess<zx_handle_t>>(parent_rsrc)); |
| zx_resource_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_resource_create->Input<uint64_t>("base", std::make_unique<ArgumentAccess<uint64_t>>(base)); |
| zx_resource_create->Input<size_t>("size", std::make_unique<ArgumentAccess<size_t>>(size)); |
| zx_resource_create->InputString<char>("name", std::make_unique<ArgumentAccess<char>>(name), |
| std::make_unique<ArgumentAccess<size_t>>(name_size)); |
| // Outputs |
| zx_resource_create->Output<zx_handle_t>( |
| ZX_OK, "resource_out", std::make_unique<ArgumentAccess<zx_handle_t>>(resource_out)); |
| |
| zx_resource_create->set_compute_statistics([](const OutputEvent* event) { |
| auto resource_out = event->GetHandleInfo( |
| event->syscall()->SearchInlineMember("resource_out", /*invoked=*/false)); |
| FX_DCHECK(resource_out != nullptr); |
| resource_out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_guest_create = Add("zx_guest_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto resource = zx_guest_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_guest_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto guest_handle = zx_guest_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| auto vmar_handle = zx_guest_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_guest_create->Input<zx_handle_t>("resource", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(resource)); |
| zx_guest_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_guest_create->Output<zx_handle_t>( |
| ZX_OK, "guest_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(guest_handle)); |
| zx_guest_create->Output<zx_handle_t>( |
| ZX_OK, "vmar_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(vmar_handle)); |
| |
| zx_guest_create->set_compute_statistics([](const OutputEvent* event) { |
| auto guest_handle = event->GetHandleInfo( |
| event->syscall()->SearchInlineMember("guest_handle", /*invoked=*/false)); |
| FX_DCHECK(guest_handle != nullptr); |
| guest_handle->AddCreationEvent(event); |
| auto vmar_handle = event->GetHandleInfo( |
| event->syscall()->SearchInlineMember("vmar_handle", /*invoked=*/false)); |
| FX_DCHECK(vmar_handle != nullptr); |
| vmar_handle->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_guest_set_trap = Add("zx_guest_set_trap", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_guest_set_trap->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_guest_set_trap->Argument<uint32_t>(SyscallType::kGuestTrap); |
| auto addr = zx_guest_set_trap->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto size = zx_guest_set_trap->Argument<size_t>(SyscallType::kSize); |
| auto port_handle = zx_guest_set_trap->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto key = zx_guest_set_trap->Argument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_guest_set_trap->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_guest_set_trap->Input<uint32_t>("kind", std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| zx_guest_set_trap->Input<zx_vaddr_t>("addr", |
| std::make_unique<ArgumentAccess<zx_vaddr_t>>(addr)); |
| zx_guest_set_trap->Input<size_t>("size", std::make_unique<ArgumentAccess<size_t>>(size)); |
| zx_guest_set_trap->Input<zx_handle_t>( |
| "port_handle", std::make_unique<ArgumentAccess<zx_handle_t>>(port_handle)); |
| zx_guest_set_trap->Input<uint64_t>("key", std::make_unique<ArgumentAccess<uint64_t>>(key)); |
| } |
| |
| { |
| Syscall* zx_vcpu_create = Add("zx_vcpu_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto guest = zx_vcpu_create->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_vcpu_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto entry = zx_vcpu_create->Argument<zx_vaddr_t>(SyscallType::kVaddr); |
| auto out = zx_vcpu_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_vcpu_create->Input<zx_handle_t>("guest", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(guest)); |
| zx_vcpu_create->Input<uint32_t>("options", std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_vcpu_create->Input<zx_vaddr_t>("entry", std::make_unique<ArgumentAccess<zx_vaddr_t>>(entry)); |
| // Outputs |
| zx_vcpu_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_vcpu_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_vcpu_resume = Add("zx_vcpu_resume", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vcpu_resume->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto packet = zx_vcpu_resume->PointerArgument<zx_port_packet_t>(SyscallType::kStruct); |
| // Inputs |
| zx_vcpu_resume->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| // Outputs |
| zx_vcpu_resume->OutputObject<zx_port_packet_t>( |
| ZX_OK, "packet", std::make_unique<ArgumentAccess<zx_port_packet_t>>(packet), |
| ZxPortPacket::GetClass()); |
| } |
| |
| { |
| Syscall* zx_vcpu_interrupt = Add("zx_vcpu_interrupt", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vcpu_interrupt->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vector = zx_vcpu_interrupt->Argument<uint32_t>(SyscallType::kUint32); |
| // Inputs |
| zx_vcpu_interrupt->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vcpu_interrupt->Input<uint32_t>("vector", |
| std::make_unique<ArgumentAccess<uint32_t>>(vector)); |
| } |
| |
| { |
| Syscall* zx_vcpu_read_state = Add("zx_vcpu_read_state", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vcpu_read_state->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_vcpu_read_state->Argument<uint32_t>(SyscallType::kVcpu); |
| auto buffer = zx_vcpu_read_state->PointerArgument<uint8_t>(SyscallType::kUint8); |
| zx_vcpu_read_state->Argument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxVcpuReadState_ZX_VCPU_STATE_Arm64 = 1; |
| const uint8_t kZxVcpuReadState_ZX_VCPU_STATE_X64 = 2; |
| // Inputs |
| zx_vcpu_read_state->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vcpu_read_state->Input<uint32_t>("kind", std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| // Outputs |
| zx_vcpu_read_state |
| ->OutputObject<zx_vcpu_state_aarch64_t>(ZX_OK, "buffer", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxVcpuStateAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), ZX_VCPU_STATE) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxVcpuReadState_ZX_VCPU_STATE_Arm64); |
| zx_vcpu_read_state |
| ->OutputObject<zx_vcpu_state_x86_t>(ZX_OK, "buffer", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxVcpuStateX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), ZX_VCPU_STATE) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxVcpuReadState_ZX_VCPU_STATE_X64); |
| } |
| |
| { |
| Syscall* zx_vcpu_write_state = Add("zx_vcpu_write_state", SyscallReturnType::kStatus); |
| // Arguments |
| auto handle = zx_vcpu_write_state->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto kind = zx_vcpu_write_state->Argument<uint32_t>(SyscallType::kVcpu); |
| auto buffer = zx_vcpu_write_state->PointerArgument<uint8_t>(SyscallType::kUint8); |
| zx_vcpu_write_state->Argument<size_t>(SyscallType::kSize); |
| // Conditional field Ids |
| const uint8_t kZxVcpuWriteState_ZX_VCPU_STATE_Arm64 = 1; |
| const uint8_t kZxVcpuWriteState_ZX_VCPU_STATE_X64 = 2; |
| const uint8_t kZxVcpuWriteState_ZX_VCPU_IO = 3; |
| // Inputs |
| zx_vcpu_write_state->Input<zx_handle_t>("handle", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(handle)); |
| zx_vcpu_write_state->Input<uint32_t>("kind", std::make_unique<ArgumentAccess<uint32_t>>(kind)); |
| zx_vcpu_write_state |
| ->InputObject<zx_vcpu_state_aarch64_t>("buffer", |
| std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxVcpuStateAArch64::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), ZX_VCPU_STATE) |
| ->DisplayIfArch(debug::Arch::kArm64) |
| ->SetId(kZxVcpuWriteState_ZX_VCPU_STATE_Arm64); |
| zx_vcpu_write_state |
| ->InputObject<zx_vcpu_state_x86_t>( |
| "buffer", std::make_unique<ArgumentAccess<uint8_t>>(buffer), ZxVcpuStateX86::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), ZX_VCPU_STATE) |
| ->DisplayIfArch(debug::Arch::kX64) |
| ->SetId(kZxVcpuWriteState_ZX_VCPU_STATE_X64); |
| zx_vcpu_write_state |
| ->InputObject<zx_vcpu_io_t>("buffer", std::make_unique<ArgumentAccess<uint8_t>>(buffer), |
| ZxVcpuIo::GetClass()) |
| ->DisplayIfEqual<uint32_t>(std::make_unique<ArgumentAccess<uint32_t>>(kind), ZX_VCPU_IO) |
| ->SetId(kZxVcpuWriteState_ZX_VCPU_IO); |
| } |
| |
| { |
| Syscall* zx_pager_create = Add("zx_pager_create", SyscallReturnType::kStatus); |
| // Arguments |
| auto options = zx_pager_create->Argument<uint32_t>(SyscallType::kUint32); |
| auto out = zx_pager_create->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pager_create->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| // Outputs |
| zx_pager_create->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_pager_create->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_pager_create_vmo = Add("zx_pager_create_vmo", SyscallReturnType::kStatus); |
| // Arguments |
| auto pager = zx_pager_create_vmo->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto options = zx_pager_create_vmo->Argument<uint32_t>(SyscallType::kUint32); |
| auto port = zx_pager_create_vmo->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto key = zx_pager_create_vmo->Argument<uint64_t>(SyscallType::kUint64); |
| auto size = zx_pager_create_vmo->Argument<uint64_t>(SyscallType::kUint64); |
| auto out = zx_pager_create_vmo->PointerArgument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pager_create_vmo->Input<zx_handle_t>("pager", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(pager)); |
| zx_pager_create_vmo->Input<uint32_t>("options", |
| std::make_unique<ArgumentAccess<uint32_t>>(options)); |
| zx_pager_create_vmo->Input<zx_handle_t>("port", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(port)); |
| zx_pager_create_vmo->Input<uint64_t>("key", std::make_unique<ArgumentAccess<uint64_t>>(key)); |
| zx_pager_create_vmo->Input<uint64_t>("size", std::make_unique<ArgumentAccess<uint64_t>>(size)); |
| // Outputs |
| zx_pager_create_vmo->Output<zx_handle_t>(ZX_OK, "out", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(out)); |
| |
| zx_pager_create_vmo->set_compute_statistics([](const OutputEvent* event) { |
| auto out = |
| event->GetHandleInfo(event->syscall()->SearchInlineMember("out", /*invoked=*/false)); |
| FX_DCHECK(out != nullptr); |
| out->AddCreationEvent(event); |
| }); |
| } |
| |
| { |
| Syscall* zx_pager_detach_vmo = Add("zx_pager_detach_vmo", SyscallReturnType::kStatus); |
| // Arguments |
| auto pager = zx_pager_detach_vmo->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto vmo = zx_pager_detach_vmo->Argument<zx_handle_t>(SyscallType::kHandle); |
| // Inputs |
| zx_pager_detach_vmo->Input<zx_handle_t>("pager", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(pager)); |
| zx_pager_detach_vmo->Input<zx_handle_t>("vmo", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(vmo)); |
| } |
| |
| { |
| Syscall* zx_pager_supply_pages = Add("zx_pager_supply_pages", SyscallReturnType::kStatus); |
| // Arguments |
| auto pager = zx_pager_supply_pages->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto pager_vmo = zx_pager_supply_pages->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto offset = zx_pager_supply_pages->Argument<uint64_t>(SyscallType::kUint64); |
| auto length = zx_pager_supply_pages->Argument<uint64_t>(SyscallType::kUint64); |
| auto aux_vmo = zx_pager_supply_pages->Argument<zx_handle_t>(SyscallType::kHandle); |
| auto aux_offset = zx_pager_supply_pages->Argument<uint64_t>(SyscallType::kUint64); |
| // Inputs |
| zx_pager_supply_pages->Input<zx_handle_t>("pager", |
| std::make_unique<ArgumentAccess<zx_handle_t>>(pager)); |
| zx_pager_supply_pages->Input<zx_handle_t>( |
| "pager_vmo", std::make_unique<ArgumentAccess<zx_handle_t>>(pager_vmo)); |
| zx_pager_supply_pages->Input<uint64_t>("offset", |
| std::make_unique<ArgumentAccess<uint64_t>>(offset)); |
| zx_pager_supply_pages->Input<uint64_t>("length", |
| std::make_unique<ArgumentAccess<uint64_t>>(length)); |
| zx_pager_supply_pages->Input<zx_handle_t>( |
| "aux_vmo", std::make_unique<ArgumentAccess<zx_handle_t>>(aux_vmo)); |
| zx_pager_supply_pages->Input<uint64_t>("aux_offset", |
| std::make_unique<ArgumentAccess<uint64_t>>(aux_offset)); |
| } |
| } |
| |
| } // namespace fidlcat |