blob: 455c271d83ce081b604e060e943072faf8b3476e [file] [log] [blame]
// 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 ZxInfoProcessV1 : public Class<zx_info_process_v1_t> {
public:
static const ZxInfoProcessV1* GetClass();
static int64_t return_code(const zx_info_process_v1_t* from) { return from->return_code; }
static bool started(const zx_info_process_v1_t* from) { return from->started; }
static bool exited(const zx_info_process_v1_t* from) { return from->exited; }
static bool debugger_attached(const zx_info_process_v1_t* from) {
return from->debugger_attached;
}
private:
ZxInfoProcessV1() : Class("zx_info_process_v1_t") {
AddField(std::make_unique<ClassField<zx_info_process_v1_t, int64_t>>(
"return_code", SyscallType::kInt64, return_code));
AddField(std::make_unique<ClassField<zx_info_process_v1_t, bool>>("started", SyscallType::kBool,
started));
AddField(std::make_unique<ClassField<zx_info_process_v1_t, bool>>("exited", SyscallType::kBool,
exited));
AddField(std::make_unique<ClassField<zx_info_process_v1_t, bool>>(
"debugger_attached", SyscallType::kBool, debugger_attached));
}
ZxInfoProcessV1(const ZxInfoProcessV1&) = delete;
ZxInfoProcessV1& operator=(const ZxInfoProcessV1&) = delete;
static ZxInfoProcessV1* instance_;
};
ZxInfoProcessV1* ZxInfoProcessV1::instance_ = nullptr;
const ZxInfoProcessV1* ZxInfoProcessV1::GetClass() {
if (instance_ == nullptr) {
instance_ = new ZxInfoProcessV1;
}
return instance_;
}
class ZxInfoProcessV2 : public Class<zx_info_process_v2_t> {
public:
static const ZxInfoProcessV2* GetClass();
static int64_t return_code(const zx_info_process_v2_t* from) { return from->return_code; }
static zx_time_t start_time(const zx_info_process_v2_t* from) { return from->start_time; }
static zx_info_process_flags_t flags(const zx_info_process_v2_t* from) { return from->flags; }
private:
ZxInfoProcessV2() : Class("zx_info_process_v2_t") {
AddField(std::make_unique<ClassField<zx_info_process_v2_t, int64_t>>(
"return_code", SyscallType::kInt64, return_code));
AddField(std::make_unique<ClassField<zx_info_process_v2_t, zx_time_t>>(
"start_time", SyscallType::kTime, start_time));
AddField(std::make_unique<ClassField<zx_info_process_v2_t, zx_info_process_flags_t>>(
"flags", SyscallType::kUint32, flags));
}
ZxInfoProcessV2(const ZxInfoProcessV2&) = delete;
ZxInfoProcessV2& operator=(const ZxInfoProcessV2&) = delete;
static ZxInfoProcessV2* instance_;
};
ZxInfoProcessV2* ZxInfoProcessV2::instance_ = nullptr;
const ZxInfoProcessV2* ZxInfoProcessV2::GetClass() {
if (instance_ == nullptr) {
instance_ = new ZxInfoProcessV2;
}
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 uint8_t kZxPortPacket_ZX_PKT_TYPE_GUEST_MEM_Arm64 = 1;
const uint8_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, uint32_t(ZX_PKT_TYPE_USER));
AddField(std::make_unique<ClassClassField<zx_port_packet_t, zx_packet_signal_t>>(
"signal", signal, ZxPacketSignal::GetClass()))
->DisplayIfEqual(type_field, uint32_t(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, uint32_t(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, uint32_t(ZX_PKT_TYPE_GUEST_MEM))
->DisplayIfArch(debug_ipc::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, uint32_t(ZX_PKT_TYPE_GUEST_MEM))
->DisplayIfArch(debug_ipc::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, uint32_t(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, uint32_t(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, uint32_t(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, uint32_t(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(