diagnostics/mojo/cros_healthd_probe.mojom

// Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

// Definitions for the probe API exposed by the cros_healthd daemon. This API is
// normally consumed by the browser.

// NOTE: This mojom should be kept in sync with the copy in Chromium's repo in
// src/chromeos/services/cros_healthd/public/mojom//cros_healthd_probe.mojom.

module chromeos.cros_healthd.mojom;

import "mojo/network_health.mojom";
import "mojo/nullable_primitives.mojom";

// An enumeration of CPU architectures.
[Extensible]
enum CpuArchitectureEnum {
  kUnknown,
  kX86_64,
  kAArch64,
  kArmv7l,
};

// An enumeration of each category of information that cros_healthd can report.
[Extensible]
enum ProbeCategoryEnum {
  kBattery,
  kNonRemovableBlockDevices,
  kCpu,
  kTimezone,
  kMemory,
  kBacklight,
  kFan,
  kStatefulPartition,
  kBluetooth,
  kSystem,
  kNetwork,
  kAudio,
  kBootPerformance,
  kBus,
  kTpm,

  // TODO(b/190459636): Rename it to kSystem after migration.
  kSystem2 = 0x10000,
};

// An enumeration of the different categories of errors that can occur when
// probing telemetry information.
[Extensible]
enum ErrorType {
  // An error reading a system file.
  kFileReadError,
  // An error parsing data into a consumable form.
  kParseError,
  // An error using a system utility.
  kSystemUtilityError,
  // The external service used to probe the information is not available.
  kServiceUnavailable,
};

// Structure that contains error information for a telemetry probe.
struct ProbeError {
  // The type of error that occurred.
  ErrorType type;
  // A debug message with more information about the error. This string is not
  // intended to be shown to the user.
  string msg;
};

// An enumeration of states a process can be in.
[Extensible]
enum ProcessState {
  // The process is running.
  kRunning,
  // The process is sleeping in an interruptible wait.
  kSleeping,
  // The process is waiting in an uninterruptible disk sleep.
  kWaiting,
  // The process is a zombie.
  kZombie,
  // The process is stopped on a signal.
  kStopped,
  // The process is stopped by tracing.
  kTracingStop,
  // The process is dead.
  kDead,
};

// Process probe result. Can either be populated with the ProcessInfo or an
// error retrieving the information.
union ProcessResult {
  // Valid ProcessInfo.
  ProcessInfo process_info;
  // The error that occurred attempting to retrieve the ProcessInfo.
  ProbeError error;
};

// Information related to a particular process.
struct ProcessInfo {
  // Command which started the process.
  string command;
  // User the process is running as.
  uint32 user_id;
  // If the process is running a real-time scheduling policy, this field is the
  // negated scheduling priority, minus one. Real-time priorities range from 1
  // to 99, so this will range from -2 to -100. If the process is not running a
  // real-time scheduling priority, this field will be the raw nice value, where
  // 0 corresponds to the user-visible high priority nice value of -20, and 39
  // corresponds to the user-visible low priority nice value of 19.
  int8 priority;
  // User-visible nice value of the process, from a low priority of 19 to a high
  // priority of -20.
  int8 nice;
  // Uptime of the process, in clock ticks.
  uint64 uptime_ticks;
  // State of the process.
  ProcessState state;
  // Total memory allocated to the process, in KiB.
  uint32 total_memory_kib;
  // Amount of resident memory currently used by the process, in KiB.
  uint32 resident_memory_kib;
  // Unused memory available to the process, in KiB. This will always be
  // |total_memory_kib| - |resident_memory_kib|.
  uint32 free_memory_kib;
  // The sum of bytes passed to system read calls. This includes terminal
  // I/O and is independent of whether the physical disk is accessed.
  uint64 bytes_read;
  // The sum of bytes passed to system write calls. This includes terminal
  // I/O and is independent of whether the physical disk is accessed.
  uint64 bytes_written;
  // Attempted count of read syscalls.
  uint64 read_system_calls;
  // Attempted count of write syscalls.
  uint64 write_system_calls;
  // Attempt to count the number of bytes which this process really did cause
  // to be fetched from the storage layer.
  uint64 physical_bytes_read;
  // Attempt to count the number of bytes which this process caused to be sent
  // to the storage layer.
  uint64 physical_bytes_written;
  // Number of bytes which this process caused to not happen, by truncating
  // pagecache.
  uint64 cancelled_bytes_written;
};

// Battery probe result. Can either be populated with the BatteryInfo or an
// error retrieving the information.
union BatteryResult {
  // Valid BatteryInfo. Null value if a battery is not present.
  BatteryInfo? battery_info;
  // The error that occurred attempting to retrieve the BatteryInfo.
  ProbeError error;
};

// Information related to the main battery.
struct BatteryInfo {
  // TODO(https://crbug.com/979245): Update "smart" cycle count.
  int64 cycle_count;
  // Current battery voltage (V)
  double voltage_now;
  // Manufacturer of the battery
  string vendor;
  // Serial number of the battery
  string serial_number;
  // Design capacity (Ah)
  double charge_full_design;
  // Full capacity (Ah)
  double charge_full;
  // Desired minimum output voltage (V)
  double voltage_min_design;
  // Model name.
  string model_name;
  // Current battery charge (Ah)
  double charge_now;
  // Current battery current (A)
  double current_now;
  // Technology of the battery
  string technology;
  // Status of the battery
  string status;

  // The fields below are optionally included if the main battery is a Smart
  // Battery as defined in http://sbs-forum.org/specs/sbdat110.pdf.

  // Manufacture date converted to yyyy-mm-dd format.
  string? manufacture_date;
  // Temperature in 0.1K. Included when the main battery is a Smart Battery.
  NullableUint64? temperature;
};

// Non-removable block device probe result. Can either be populated with the
// NonRemovableBlockDeviceInfo or an error retrieving the information.
union NonRemovableBlockDeviceResult {
  // Valid NonRemovableBlockDeviceInfo.
  array<NonRemovableBlockDeviceInfo> block_device_info;
  // The error that occurred attempting to retrieve the
  // NonRemovableBlockDeviceInfo.
  ProbeError error;
};

// Unions for device-specific data fields. |other| is provided by the default
// data adapter and filled with a default value for the unknown device type.

// The manufacturer of the block device.
union BlockDeviceVendor {
  uint32 nvme_subsystem_vendor;
  uint16 emmc_oemid;
  uint16 other;
};

// The manufacturer-specific product identifier.
union BlockDeviceProduct {
  uint32 nvme_subsystem_device;
  uint64 emmc_pnm;
  uint16 other;
};

// The revision of the device's hardware.
union BlockDeviceRevision {
  uint8 nvme_pcie_rev;
  uint8 emmc_prv;
  uint16 other;
};

// The revision of the device's firmware.
union BlockDeviceFirmware {
  uint64 nvme_firmware_rev;
  uint64 emmc_fwrev;
  uint16 other;
};

// Purpose of the storage device.
[Extensible]
enum StorageDevicePurpose {
  kUnknown,
  kBootDevice,
  kSwapDevice,
};

// Information related to a specific non-removable block device.
struct NonRemovableBlockDeviceInfo {
  // IO statistics

  // Bytes read since last boot.
  uint64 bytes_read_since_last_boot;
  // Bytes written since last boot.
  uint64 bytes_written_since_last_boot;
  // Time spent reading since last boot.
  uint64 read_time_seconds_since_last_boot;
  // Time spent writing since last boot.
  uint64 write_time_seconds_since_last_boot;
  // Time spent doing I/O since last boot. Counts the time the disk and queue
  // were busy, so unlike the fields above, parallel requests are not counted
  // multiple times.
  uint64 io_time_seconds_since_last_boot;
  // Time spent discarding since last boot. Discarding is writing to clear
  // blocks which are no longer in use. Supported on kernels 4.18+.
  NullableUint64? discard_time_seconds_since_last_boot;

  // Device identification.

  // Device vendor identification.
  BlockDeviceVendor vendor_id;
  // Device product identification.
  BlockDeviceProduct product_id;
  // Device revision.
  BlockDeviceRevision revision;
  // Device model.
  string name;
  // Device size in bytes.
  uint64 size;
  // Firmware version.
  BlockDeviceFirmware firmware_version;
  // Storage type, could be MMC / NVMe / ATA, based on udev subsystem.
  string type;
  // Purpose of the device e.g. "boot", "swap".
  StorageDevicePurpose purpose;

  // Additional identification.

  // The path of this storage on the system. It is useful if caller needs to
  // correlate with other information.
  string path;
  // Manufacturer ID, 8 bits.
  uint8 manufacturer_id;
  // PSN: Product serial number, 32 bits
  uint32 serial;
};

// CPU probe result. Can either be populated with the CpuInfo or an error
// retrieving the information.
union CpuResult {
  // Valid CpuInfo.
  CpuInfo cpu_info;
  // The error that occurred attempting to retrieve the CpuInfo.
  ProbeError error;
};

// Information about the device's CPUs.
struct CpuInfo {
  // Number of total threads available.
  uint32 num_total_threads;
  // The CPU architecture - it's assumed all of a device's CPUs share an
  // architecture.
  CpuArchitectureEnum architecture;
  // Information about the device's physical CPUs.
  array<PhysicalCpuInfo> physical_cpus;
  // Information about the CPU temperature channels.
  array<CpuTemperatureChannel> temperature_channels;
  // Information about keylocker.
  KeylockerInfo? keylocker_info;
};

// Information related to Keylocker.
struct KeylockerInfo {
  // Has Keylocker been configured or not.
  bool  keylocker_configured;
};

// Information related to a particular physical CPU.
struct PhysicalCpuInfo {
  // The CPU model name, if available.
  string? model_name;
  // Logical CPUs corresponding to this physical CPU.
  array<LogicalCpuInfo> logical_cpus;
};

// Information related to a particular logical CPU.
struct LogicalCpuInfo {
  // The max CPU clock speed in kHz.
  uint32 max_clock_speed_khz;
  // Maximum frequency the CPU is allowed to run at, by policy.
  uint32 scaling_max_frequency_khz;
  // Current frequency the CPU is running at.
  uint32 scaling_current_frequency_khz;
  // Time spent in user mode since last boot. USER_HZ can be converted to
  // seconds with the conversion factor given by sysconf(_SC_CLK_TCK).
  uint64 user_time_user_hz;
  // Time spent in system mode since last boot. USER_HZ can be converted to
  // seconds with the conversion factor given by sysconf(_SC_CLK_TCK).
  uint64 system_time_user_hz;
  // Idle time since last boot. USER_HZ can be converted to seconds with the
  // conversion factor given by sysconf(_SC_CLK_TCK).
  uint64 idle_time_user_hz;
  // Information about the logical CPU's time in various C-states.
  array<CpuCStateInfo> c_states;
};

// Information about a CPU's C-states.
struct CpuCStateInfo {
  // Name of the state.
  string name;
  // Time spent in the state since the last reboot, in microseconds.
  uint64 time_in_state_since_last_boot_us;
};

// Information about a single CPU temperature channel.
struct CpuTemperatureChannel {
  // Temperature channel label, if found on the device.
  string? label;
  // CPU temperature in Celsius.
  int32 temperature_celsius;
};

// Timezone probe result. Can either be populated with the TimezoneInfo or an
// error retrieving the information.
union TimezoneResult {
  // Valid TimezoneInfo.
  TimezoneInfo timezone_info;
  // The error that occurred attempting to retrieve the TimezoneInfo.
  ProbeError error;
};

// Timezone information.
struct TimezoneInfo {
  // The timezone of the device in POSIX standard.
  string posix;
  // The timezone region of the device.
  string region;
};

// Memory probe result. Can either be populated with the MemoryInfo or an
// error retrieving the information.
union MemoryResult {
  // Valid MemoryInfo.
  MemoryInfo memory_info;
  // The error that occurred attempting to retrieve the MemoryInfo.
  ProbeError error;
};

// Memory information.
struct MemoryInfo {
  // Total memory, in KiB.
  uint32 total_memory_kib;
  // Free memory, in KiB.
  uint32 free_memory_kib;
  // Available memory, in KiB.
  uint32 available_memory_kib;
  // Number of page faults since the last boot.
  uint64 page_faults_since_last_boot;
};

// Backlight probe result. Can either be populated with the BacklightInfo or an
// error retrieving the information.
union BacklightResult {
  // Valid BacklightInfo.
  array<BacklightInfo> backlight_info;
  // The error that occurred attempting to retrieve the BacklightInfo.
  ProbeError error;
};

// Backlight information.
struct BacklightInfo {
  // Path to this backlight on the system. Useful if the caller needs to
  // correlate with other information.
  string path;
  // Maximum brightness for the backlight.
  uint32 max_brightness;
  // Current brightness of the backlight, between 0 and max_brightness.
  uint32 brightness;
};

// Fan probe result. Can either be populated with the FanInfo or an error
// retrieving the information
union FanResult {
  // A list of valid FanInfo.
  array<FanInfo> fan_info;
  // The error that occurred attempting to retrieve the FanInfo.
  ProbeError error;
};

// Fan information.
struct FanInfo {
  // Fan speed in RPM.
  uint32 speed_rpm;
};

// Stateful partition probe result. Can either be populated with a valid
// StatefulPartitionInfo or an error retrieving the information.
union StatefulPartitionResult {
  // A valid StatefulPartitionInfo.
  StatefulPartitionInfo partition_info;
  // The error that occurred attempting to retrieve the StatefulPartitionInfo.
  ProbeError error;
};

// Stateful partition info
struct StatefulPartitionInfo {
  // Available space for user data storage in the device in bytes.
  uint64 available_space;
  // Total space for user data storage in the device in bytes.
  uint64 total_space;
  // File system on stateful partition. e.g. ext4.
  string filesystem;
  // Source of stateful partition. e.g. /dev/mmcblk0p1.
  string mount_source;
};

// Bluetooth probe result. Can either be populated with the BluetoothAdapterInfo
// or an error retrieving the information.
union BluetoothResult {
  // Valid BluetoothAdapterInfo.
  array<BluetoothAdapterInfo> bluetooth_adapter_info;
  // The error that occurred attempting to retrieve the BluetoothAdapterInfo.
  ProbeError error;
};

// Information related to one of a device's Bluetooth adapters.
struct BluetoothAdapterInfo {
  // The name of the adapter.
  string name;
  // The MAC address of the adapter.
  string address;
  // Indicates whether the adapter is on or off.
  bool powered;
  // The number of devices connected to this adapter.
  uint32 num_connected_devices;
};

// System probe result. Can either be populated with the SystemInfo or an error
// retrieving the information.
// DEPRECATED(b/188508561): Use SystemResultV2 instead.
union SystemResult {
  // Valid SystemInfo.
  SystemInfo system_info;
  // The error that occurred attempting to retrieve SystemInfo.
  ProbeError error;
};

// System probe result. Can either be populated with the SystemInfoV2 or an
// error retrieving the information.
union SystemResultV2 {
  // Valid SystemInfoV2.
  SystemInfoV2 system_info_v2;
  // The error that occurred attempting to retrieve SystemInfo.
  ProbeError error;
};

// System Information.
// DEPRECATED(b/188508561): Use SystemInfoV2 instead.
struct SystemInfo {
  // The date the device was first activated.
  // Format: YYYY-WW.
  string? first_power_date;
  // The date the device was manufactured (finalized in factory).
  // Format: YYYY-MM-DD.
  string? manufacture_date;
  // The product SKU number.
  string? product_sku_number;
  // The product serial number.
  string? product_serial_number;
  // The product model name.
  string? product_model_name;
  // Contents of CrosConfig in /arc/build-properties/marketing-name.
  string marketing_name;
  // The BIOS version.
  string? bios_version;
  // The product name of the motherboard.
  string? board_name;
  // The version of the motherboard.
  string? board_version;
  // The chassis type of the device. The values reported by chassis type are
  // mapped in
  // www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.0.0.pdf.
  NullableUint64? chassis_type;
  // The product name (model) of the system.
  string? product_name;
  // The OS version of the system.
  OsVersion os_version;
};

// System Information.
// TODO(b/190459636): Rename it to SystemInfo after migration.
struct SystemInfoV2 {
  // The info related to the OS.
  OsInfo os_info;
  // The info from the VPD cache.
  VpdInfo? vpd_info;
  // The info from DMI (x86 only). The info from here should only be used for
  // logging and debugging.
  DmiInfo? dmi_info;
};

// The OS information.
struct OsInfo {
  // Google code name for the given model. While it is OK to use this string for
  // human-display purposes (such as in a debug log or help dialog), or for a
  // searchable-key in metrics collection, it is not recommended to use this
  // property for creating model-specific behaviors.
  string code_name;
  // Contents of CrosConfig in /arc/build-properties/marketing-name.
  string? marketing_name;
  // The OS version of the system.
  OsVersion os_version;
  // The boot flow used by the current boot.
  BootMode boot_mode;
};

// Structure containing information about the operating system version of the
// device. This structure decomposes a full version string
// (e.g. "87.13544.59.0") into its parts:
struct OsVersion {
  // The OS version release milestone (e.g. "87").
  string release_milestone;
  // The OS version build number (e.g. "13544").
  string build_number;
  // The OS version patch number (e.g. "59.0").
  string patch_number;
  // The OS release channel (e.g. "stable-channel").
  string release_channel;
};

// The boot mode of the current os.
[Extensible]
enum BootMode {
  kUnknown = 0,
  // Boot with Chrome OS firmware.
  kCrosSecure,
  // Boot with EFI
  kCrosEfi,
  // Boot with Legacy BIOS.
  kCrosLegacy,
  // Boot with EFI security boot.
  kCrosEfiSecure,
};

// The list of VPD fields are available in the ChromeOS Partner Site document
// "VPD Field Requirements":
//    https://chromeos.google.com/partner/dlm/docs/factory/vpd.html
// Note that all the fields (include required fields) are not guaranteed to be
// exist in some situation. (e.g. in a early stage device)
struct VpdInfo {
  // A unique identifier of the device. (Required RO VPD field)
  string? serial_number;
  // Defines a market region where devices share a particular configuration of
  // keyboard layout, language, and timezone. (Required VPD field)
  string? region;
  // The date the device was manufactured. (Required RO VPD field)
  // Format: YYYY-MM-DD.
  string? mfg_date;
  // The date the device was first activated. (Runtime RW VPD field)
  // Format: YYYY-WW.
  string? activate_date;
  // The product SKU number. (Optional RO VPD field. b/35512367)
  string? sku_number;
  // The product model name. (Optional RO VPD field. b/35512367)
  string? model_name;
};

// DMI (a.k.a. SMBIOS) is only supported on x86 platform. These info can be used
// to identify the hardware.
struct DmiInfo {
  // The BIOS vendor.
  string? bios_vendor;
  // The BIOS version.
  string? bios_version;
  // The product name of the motherboard.
  string? board_name;
  // The vendor of the motherboard.
  string? board_vendor;
  // The version of the motherboard.
  string? board_version;
  // The vendor of the chassis.
  string? chassis_vendor;
  // The chassis type of the device. The values reported by chassis type are
  // mapped in
  // www.dmtf.org/sites/default/files/standards/documents/DSP0134_3.0.0.pdf.
  NullableUint64? chassis_type;
  // The product family name.
  string? product_family;
  // The product name (model) of the system.
  string? product_name;
  // The product version.
  string? product_version;
  // The system vendor name.
  string? sys_vendor;
};

// Network probe result. Can either be populated with the NetworkHealthSnapshot
// or an error retrieving the information.
union NetworkResult {
  // Valid NetworkHealthSnapshot.
  chromeos.network_health.mojom.NetworkHealthState network_health;
  // The error that occurred attempting to retrieve the NetworkHealthSnapshot.
  ProbeError error;
};

// Audio probe result. Can either be populated with the AudioInfo or an
// error retrieving the information.
union AudioResult {
  // Valid AudioInfo.
  AudioInfo audio_info;
  // The error that occurred attempting to retrieve the AudioInfo.
  ProbeError error;
};

// Audio information.
struct AudioInfo {
  // Is active output device mute or not.
  bool output_mute;
  // Is active input device mute or not.
  bool input_mute;
  // Active output device's volume in [0, 100].
  uint64 output_volume;
  // Active output device's name.
  string output_device_name;
  // Active input device's gain in [0, 100].
  uint32 input_gain;
  // Active input device's name.
  string input_device_name;
  // Numbers of underruns.
  uint32 underruns;
  // Numbers of severe underruns.
  uint32 severe_underruns;
};

// Boot performance result.
union BootPerformanceResult {
  // Valid BootPerformanceInfo.
  BootPerformanceInfo boot_performance_info;
  // The error that occurred attempting to retrieve the BootPerformanceInfo.
  ProbeError error;
};

// Boot performance information.
struct BootPerformanceInfo {
  // Total time since power on to login screen prompt.
  double boot_up_seconds;
  // The timestamp when power on.
  double boot_up_timestamp;
  // Total time(rough) since shutdown start to power off.
  // Only meaningful when shutdown_reason is not "N/A".
  double shutdown_seconds;
  // The timestamp when shutdown.
  // Only meaningful when shutdown_reason is not "N/A".
  double shutdown_timestamp;
  // The shutdown reason (including reboot).
  string shutdown_reason;
};

// Bus probe result. Can either be populated with the BusDevice or an error
// retrieving the information.
union BusResult {
  // Valid BusDevice.
  array<BusDevice> bus_devices;
  // The error that occurred attempting to retrieve the BusDevice.
  ProbeError error;
};

// The classes of the bus devices. Can be used to group the devices by their
// use.
[Extensible]
enum BusDeviceClass {
  // For the devices which cannot be classified.
  kOthers = 0,
  kDisplayController,
  kEthernetController,
  kWirelessController,
  kBluetoothAdapter,
};

// The bus device info.
struct BusDevice {
  // The vendor / product name of the device. These are extracted from the
  // databases on the system and should only be used for showing / logging.
  // Don't use these to identify the devices.
  string vendor_name;
  string product_name;
  // The class of the device.
  BusDeviceClass device_class;
  // The info related to specific bus type.
  BusInfo bus_info;
};

// The info related to specific bus type.
union BusInfo {
  // The info related to pci.
  PciBusInfo pci_bus_info;
  // The info related to usb.
  UsbBusInfo usb_bus_info;
};

// The info related to pci.
struct PciBusInfo {
  // These fields can be used to classify / identify the pci devices. See the
  // pci.ids database for the values. (https://github.com/gentoo/hwids)
  uint8 class_id;
  uint8 subclass_id;
  uint8 prog_if_id;
  uint16 vendor_id;
  uint16 device_id;
  // The driver used by the device. This is the name of the matched driver which
  // is registered in the kernel. See "{kernel root}/drivers/". for the list of
  // the built in drivers.
  string? driver;
};

// The info related to usb.
struct UsbBusInfo {
  // These fields can be used to classify / identify the usb devices. See the
  // usb.ids database for the values. (https://github.com/gentoo/hwids)
  uint8 class_id;
  uint8 subclass_id;
  uint8 protocol_id;
  uint16 vendor_id;
  uint16 product_id;
  // The usb interfaces under the device. A usb device has at least one
  // interface. Each interface may or may not work independently, based on each
  // device. This allows a usb device to provide multiple features.
  // The interfaces are sorted by the |interface_number| field.
  array<UsbBusInterfaceInfo> interfaces;
};

// The info related to usb interfaces.
struct UsbBusInterfaceInfo {
  // The zero-based number (index) of the interface.
  uint8 interface_number;
  // These fields can be used to classify / identify the usb interfaces. See the
  // usb.ids database for the values.
  uint8 class_id;
  uint8 subclass_id;
  uint8 protocol_id;
  // The driver used by the device. This is the name of the matched driver which
  // is registered in the kernel. See "{kernel root}/drivers/". for the list of
  // the built in drivers.
  string? driver;
};

// TPM probe result. Can either be populated with the TpmInfo or an error
// retrieving the information.
union TpmResult {
  // Valid TpmInfo.
  TpmInfo tpm_info;
  // The error that occurred attempting to retrieve the TpmInfo.
  ProbeError error;
};

// Information of the Trusted Platform Module(TPM).
struct TpmInfo {
  // TPM version related information.
  TpmVersion version;
  // TPM status related information.
  TpmStatus status;
  // TPM dictionary attack (DA) related information.
  TpmDictionaryAttack dictionary_attack;
  // TPM attestation related information.
  TpmAttestation attestation;
  // TPM supported features information.
  TpmSupportedFeatures supported_features;
  // [Do NOT use] TPM did_vid file. This field is only used in Cloudready
  // project. It is going to drop the support in few milestone.
  // TODO(b/199686982): Remove this.
  string? did_vid;
};

// The version of Google security chip(GSC).
[Extensible]
enum TpmGSCVersion {
  // For the devices which cannot be classified.
  kNotGSC = 0,
  // Devices with Cr50 firmware.
  kCr50,
  // Devices with Ti50 firmware.
  kTi50,
};

// TPM version related information.
struct TpmVersion {
  // GSC version.
  TpmGSCVersion gsc_version;
  // TPM family. We use the TPM 2.0 style encoding, e.g.:
  //  * TPM 1.2: "1.2" -> 0x312e3200
  //  * TPM 2.0: "2.0" -> 0x322e3000
  uint32 family;
  // TPM spec level.
  uint64 spec_level;
  // Manufacturer code.
  uint32 manufacturer;
  // TPM model number.
  uint32 tpm_model;
  // Firmware version.
  uint64 firmware_version;
  // Vendor specific information.
  string? vendor_specific;
};

// TPM status related information.
struct TpmStatus {
  // Whether a TPM is enabled on the system.
  bool enabled;
  // Whether the TPM has been owned.
  bool owned;
  // Whether the owner password is still retained.
  bool owner_password_is_present;
};

// TPM dictionary attack (DA) related information.
struct TpmDictionaryAttack {
  // The current dictionary attack counter value.
  uint32 counter;
  // The current dictionary attack counter threshold.
  uint32 threshold;
  // Whether the TPM is in some form of dictionary attack lockout.
  bool lockout_in_effect;
  // The number of seconds remaining in the lockout.
  uint32 lockout_seconds_remaining;
};

// TPM attestation related information.
struct TpmAttestation {
  // Is prepared for enrollment? True if prepared for *any* CA.
  bool prepared_for_enrollment;
  // Is enrolled (AIK certificate created)? True if enrolled with *any* CA.
  bool enrolled;
};

// TPM supported features information.
struct TpmSupportedFeatures {
  // Whether the u2f is supported or not.
  bool support_u2f;
  // Whether the pinweaver is supported or not.
  bool support_pinweaver;
  // Whether the platform supports runtime TPM selection or not.
  bool support_runtime_selection;
  // Whether the TPM is allowed to use or not.
  bool is_allowed;
};

// A collection of all the device's telemetry information that cros_healthd is
// capable of reporting. Note that every field in TelemetryInfo is nullable, and
// the response for a particular ProbeTelemetryInfo request will only contain
// fields corresponding to the categories passed to the ProbeTelemetryInfo
// request. All optional array members will be null if cros_healthd did not
// attempt to fetch that information, and size zero if cros_healthd did attempt
// to fetch that information, but was unable to.
struct TelemetryInfo {
  // Information about the device's main battery. Only present when kBattery was
  // included in the categories input to ProbeTelemetryInfo.
  BatteryResult? battery_result;
  // Information about all of the device's non-removable block devices. Only
  // present when kNonRemovableBlockDevices was included in the categories input
  // to ProbeTelemetryInfo.
  NonRemovableBlockDeviceResult? block_device_result;
  // Information about each of the device's CPUs. Only present when kCpu was
  // included in the categories input to ProbeTelemetryInfo.
  CpuResult? cpu_result;
  // Information about the device's timezone. Only present when kTimezone was
  // included in the categories input to ProbeTelemetryInfo.
  TimezoneResult? timezone_result;
  // Information about the system's memory. Only present when kMemory was
  // included in the categories input to ProbeTelemetryInfo.
  MemoryResult? memory_result;
  // Information about all of the device's backlights. Only present when
  // kBacklight was included in the categories input to ProbeTelemetryInfo.
  BacklightResult? backlight_result;
  // Information about each of the device's fans. Only present when kFan was
  // included in the categories input to ProbeTelemetryInfo.
  FanResult? fan_result;
  // Information about the stateful partition. Only present when
  // kStatefulPartition was included in the categories input to
  // ProbeTelemetryInfo.
  StatefulPartitionResult? stateful_partition_result;
  // Information about the device's Bluetooth adapters and devices. Only present
  // when kBluetooth was included in the categories input to ProbeTelemetryInfo.
  BluetoothResult? bluetooth_result;
  // Information about the system. Only present when kSystem was included in
  // the categories input to ProbeTelemetryInfo.
  // DEPRECATED(b/188508561): Use system_result_v2 instead.
  SystemResult? system_result;
  // Information about the networking devices and associated networks of the
  // system. Only present when kNetwork was included in the categories input to
  // ProbeTelemetryInfo.
  NetworkResult? network_result;
  // Information about the audio devices. Only present when kAudio was included
  // in the categories input to ProbeTelemetryInfo.
  AudioResult? audio_result;
  // Information about boot performance. Only present when kBootPerformance was
  // included in the categories input to ProbeTelemetryInfo.
  BootPerformanceResult? boot_performance_result;
  // Information about the bus devices. Only present when kBus was included
  // in the categories input to ProbeTelemetryInfo.
  BusResult? bus_result;
  // Information about the system. Only present when kSystem2 was included in
  // the categories input to ProbeTelemetryInfo.
  SystemResultV2? system_result_v2;
  // Information about the tpm. Only present when kTpm was included in
  // the categories input to ProbeTelemetryInfo.
  TpmResult? tpm_result;
};